python 数据类型
一,数字
Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些数字对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用，例如：
del var
del var_a, var_b
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
我们可以使用十六进制和八进制来代表整数：
>>> number = 0xA0F # 十六进制
>>> number
2575
>>> number=0o37 # 八进制
>>> number
31
- Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
- int(x) 将x转换为一个整数。
- float(x) 将x转换到一个浮点数。
- complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
以下实例将浮点数变量 a 转换为整数：
>>> a = 1.0
>>> int(a)
1
数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： +, -, ***** 和 /, 和其它语言（如Pascal或C）里一样。例如：
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
注意：在不同的机器上浮点运算的结果可能会不一样。
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：
>>> 17 / 3 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3 # 整数除法返回向下取整后的结果
5
>>> 17 % 3 # ％操作符返回除法的余数
2
>>> 5 * 3 + 2
17
注意：//得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>>
Python 可以使用 ** 操作来进行幂运算：
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2的7次方
128
不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
python是强类型动态语言,即字符串格式的1和数字格式的1不能做数学运算
数学常量
| 常量 | 描述 |
|---|---|
| pi | 数学常量 pi（圆周率，一般以π来表示） |
| e | 数学常量 e，e即自然常数（自然常数）。 |
二,字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!' var2 = "Runoob"
转义字符
在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
| % | 格式字符串 | 请看下一节内容。 |
字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!
python字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 | |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
#!/usr/bin/python3 para_str = """这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( \t )。 也可以使用换行符 [ \n ]。 """ print (para_str)
以上实例执行结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
name = 'Runoob'
f'Hello {name}' # 替换变量
f'{1+2}' # 使用表达式
'3'
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
x = 1
print(f'{x+1}') # Python 3.6
2
x = 1
print(f'{x+1=}') # Python 3.8
'x+1=2'
Unicode 字符串
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。
字符串内建方法
Python 的字符串常用内建函数如下：
常用方法
1,按索引取值(正向取+反向取)
res='1234567'
print(res[0])
print(res[-1])
2,切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串
msg='hello world'
# 顾头不顾尾
res=msg[0:5] #x
print(res)
print(msg)
#步长
res=msg[0:5:2] # 0 2 4
print(res) # hlo
#反向步长
res=msg[5:0:-1]
print(res) #" olle"
#不填写时的默认值
msg='hello world'
res=msg[:] # res=msg[0:11]
print(res)
res=msg[::-1] # 把字符串倒过来
print(res)
3 长度 len
msg='hello world'
print(len(msg))
4 成员运算in和not in
判断一个子字符串是否存在于一个大字符串中
print("alex" in "alex is sb")
print("alex" not in "alex is sb")
print(not "alex" in "alex is sb") # 不推荐使用
5 移除字符串左右两侧的符号strip
默认去掉的空格
msg=' egon '
res=msg.strip()
print(msg) # 不会改变原值
print(res) # 是产生了新值
括号内传什么参数就去掉什么,直到遇到第一个不能删除的字符
msg='****egon****'
print(msg.strip('*'))
注意删除多个字符时：只要头尾有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。
str = '123132231213321312==321312213231123132'
print(str.strip('123'))
以上代码输出结果为：==
msg='****e*****gon****'
print(msg.strip('*'))
msg='**/*=-**egon**-=()**'
print(msg.strip('*/-=()'))
还有左删除和右删除 lstrip()和 rstrip()
6 切分split：把一个字符串按照某种分隔符进行切分，得到一个列表
默认分隔符是空格
info='egon 18 male'
res=info.split()
print(res)
指定分隔符
info='egon:18:male'
res=info.split(':')
print(res)
指定分隔次数
info='egon:18:male'
res=info.split(':',1)
print(res)
**把列表拼接成字符串 join **
l=['egon', '18', 'male']
res=l[0]+":"+l[1]+":"+l[2]
res=":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res)
l=[1,"2",'aaa'] # 不能拼接有非字符串的列表,会报错!
":".join(l)
7 用于for循环
info='egon:18:male'
for x in info:
print(x)
8 大小写转换 lower,upper
全大写全小写
msg='AbbbCCCC'
print(msg.lower())
print(msg.upper())
9 判断开头结尾 startswith,endswith
返回布尔值
print("alex is sb".startswith("alex"))
print("alex is sb".endswith('sb'))
10 格式化字符 format
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。还可以用字典传值
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
11 maketrans 和translate 群替换字符串
maketrans创建映射关系,translate负责替换
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print (str.translate(trantab))
th3s 3s str3ng 2x1mpl2....w4w!!!
参数详解:
一个参数，该参数必须为字典
>>> d = {'a':'1','b':'2','c':'3','d':'4','e':'5','s':'6'}
>>> trantab = str.maketrans(d)
>>> st='just do it'
>>> print(st.translate(trantab))
ju6t 4o it
两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符
>>> x = 'abcdefs'
>>> y = '1234567'
>>> st='just do it'
>>> trantab = str.maketrans(x,y)
>>> print(st.translate(trantab))
ju7t 4o it
三个参数 x、y、z，第三个参数 z 必须是字符串，其字符将被映射为 None，即删除该字符；如果 z 中字符与 x 中字符重复，该重复的字符在最终结果中还是会被删除。也就是无论是否重复，只要有第三个参数 z，z 中的字符都会被删除。
>>> x = 'abcdefs'
>>> y='1234567'
>>> z='ot'
>>> st='just do it'
>>> trantab = str.maketrans(x,y,z)
>>> print(st.translate(trantab))
ju7 4 i
>>>x = 'abst'
>>>y = '1234'
>>>z = 's'
>>>st = 'just do it'
>>>trantab = str.maketrans(x,y,z)
>>>print(st.translate(trantab))
ju4 do i4
replace 单次替换
msg="you can you up no can no bb"
print(msg.replace("you","YOU",))
print(msg.replace("you","YOU",1))
12 isdigit
判断字符串是否由纯数字组成
print('123'.isdigit())
print('12.3'.isdigit())
其他方法
1 查找,计数
find,rfind,index,rindex,count
msg='hello egon hahaha' 找到返回起始索引
msg='hello egon hahaha'
print(msg.find('e')) # 返回要查找的字符串在大字符串中的起始索引
print(msg.find('egon'))
print(msg.index('e'))
print(msg.index('egon'))
找不到时两种方法的不同情况
msg='hello egon hahaha'
print(msg.find('xxx')) # 返回-1，代表找不到
print(msg.index('xxx')) # 抛出异常
msg='hello egon hahaha egon、 egon'
print(msg.count('egon'))
2 设置填充
center,ljust,rjust,zfill
居中,左对齐,右对齐,zero fill用零填充
print('egon'.center(50,'*'))
print('egon'.ljust(50,'*'))
print('egon'.rjust(50,'*'))
print('egon'.zfill(10))
3 设置制表符的空格数 expandtabs
msg='hello\tworld'
print(msg.expandtabs(2)) # 设置制表符代表的空格数为2
4 样式调整 capitalize,swapcase,title
整个字符串的第一个单词首字母大写,大小写翻转,每个单词的首字母大写
print("hello world egon".capitalize())
print("Hello WorLd EGon".swapcase())
print("hello world egon".title())
5 is数字系列
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
isdigit只能识别：num1、num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
isnumberic可以识别：num2、num3、num4
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
isdecimal只能识别：num2
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
is其他
print('abc'.islower()) # 是否全小写
print('ABC'.isupper()) # 是否全大写
print('Hello World'.istitle()) # 是否所有单词首字母大写
print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
print('ad'.isalpha()) # 字符串由由字母组成结果为True
print(' '.isspace()) # 字符串由空格组成结果为True
print('print'.isidentifier()) # 是否合法标识符，True
print('age_of_egon'.isidentifier()) #True
print('1age_of_egon'.isidentifier()) # False
三,列表
作用：列表一般用于按位置存放多个值
定义:列表是一个由多个数据组成的数据结构
l=[1,1.2,'a']
# 相当于l=list([1,1.2,'a'])
print(type(l))
# <class 'list'>
类型转换: 能够被for循环遍历的类型都可以使用list()转成列表
res=list('hello')
print(res)
s = "hello"
l = []
for i in s:
l.append(i)
print(l)
列表运算
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
列表内建方法
常用方法
1、按索引存取值(正向存取+反向存取)：即可以取也可以改
l=[111,'egon','hello']
# 正向取值
print(l[0])
# 反向取值
print(l[-1])
# 可以取也可以改：索引存在则修改对应的值
l[0]=222
print(l)
# 无论是取值操作还是赋值操作：索引不存在则报错
l[3]=333
2、切片(顾头不顾尾，步长)
l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[0:3])
# [111, 'egon', 'hello']
print(l[0:5:2]) # 取索引为0 2 4的值
# [111, 'hello', 'b']
print(l[0:len(l)])
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[:])
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
new_l=l[:] # 切片等同于拷贝行为，而且相当于浅copy
print(id(l))
# 2277356332168
print(id(new_l))
# 2277356332936
l[-1][0]=1111111 # 修改原列表,验证切片与浅拷贝类似
print(l)
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
print(new_l)
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
print(l[::-1])
# [[1111111, 2, 3], 'd', 'c', 'b', 'a', 'hello', 'egon', 111]
3、长度
print(len([1, 2, 3]))
# 3
4、成员运算in和not in
print('aaa' in ['aaa', 1, 2])
# True
print(1 in ['aaa', 1, 2])
# True
5、往列表中添加值
追加 append
在列表尾部添加单个数据
l=[111,'egon','hello']
l.append(3333)
l.append(4444)
print(l)
# l=[111,'egon','hello',3333,4444]
插入 insert
按照填入的索引,在对应的位置插入数据
l=[111,'egon','hello']
l.insert(0,'alex')
print(l)
# ['alex', 111, 'egon', 'hello']
**解压添加值 extend **
extend可以将新列表内的数据解压添加到原列表
如果我们想将一个新的列表内的数据添加到原列表,使用append无法实现,我们可以使用extend方法
new_l = [1, 2, 3]
l = [111, 'egon', 'hello']
for item in new_l:
l.append(item)
print(l)
# [111, 'egon', 'hello', 1, 2, 3]
# 实现了功能
l.extend('abc')
print(l)
# [111, 'egon', 'hello', 1, 2, 3, 'a', 'b', 'c']
6 删除
方式一：根据索引删除，只是单纯的删除、没有返回值
l = [111, 'egon', 'hello']
del l[1]
print(l)
x = del l[1] # 查看返回值,抛出异常，不支持赋值语法
方式二：list.pop()根据索引删除，会返回删除的值(经常使用)
不输入索引时默认删除最后一个数据
l = [111, 'egon', 'hello', 55]
l.pop() # 不指定索引默认删除最后一个
l.pop()
print(l)
# [111, 'egon']
res = l.pop(1)
print(l)
# [111]
print(res)
# egon
方式三：l.remove()根据元素删除，返回None
l = [111, 'egon', [1,2,3],'hello']
l.remove([1,2,3])
print(l)
# [111, 'egon', 'hello']
res=l.remove('egon') # 返回值为None
print(res)
# None
7、循环与列表
不要在循环中对列表进行删除操作,会导致索引错乱,
l=[1,'aaa','bbb']
for x in l:
l.pop(1)
print(x)
其他方法
1、l.count()
输入内容在列表中出现的次数
print(l.count('aaa'))
2、l.index()
查找方法,查找输入内容第一次出现的位置的索引
print(l.index('aaa'))
print(l.index('aaaaaaaaa')) # 找不到报错
3、l.clear()
清空列表
l.clear()
4、l.reverse():
注意: reverse不是排序后翻转，是将列表的索引翻转
l = [1, 'egon','alex','lxx']
l.reverse()
print(l)
5、l.sort(): 列表内元素必须是同种类型才可以排序
l=[11,-3,9,2,3.1]
l.sort() # 默认从小到大排，称之为升序
l.sort(reverse=True) # 从大到小排，设置为降序
print(l)
l=[11,'a',12] # 不同类型报错!
l.sort()
l=['c','e','a'] # 按ascii码排序,A<a
l.sort()
print(l)
字符串可以比大小，按照对应的位置的字符依次pk
字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
print('a'>'b')
# False
print('abz'>'abcdefg')
# True
列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
l1=[1,'abc','zaa']
l2=[1,'abc','zb']
print(l1 < l2)
# True
max(list)返回列表元素最大值
min(list) 返回列表元素最小值
四,元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组就是"一个不可变的列表"
1、作用：按照索引/位置存放多个值，只用于读不用于改
2、定义:（）内用逗号分隔开多个任意类型的元素
t=(1,1.3,'aa')
# 相当于t=tuple((1,1.3,'aa'))
print(t,type(t))
# (1, 1.3, 'aa') <class 'tuple'>
x=(10) # 单独一个括号代表包含的意思为整数数据类型!!
print(x,type(x))
# 10 <class 'int'>
t=(10,) # 如果元组中只有一个元素，必须加逗号
print(t,type(t))
# (10,) <class 'tuple'>
元组是不可变数据类型:不可变体现在它第一层的数据指向的内存地址不能更改.
t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
t[0]=11111
# TypeError: 'tuple' object does not support item assignment
t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
print(id(t[0]),id(t[1]))
# 1358874288 2579862236488
t[0]=111111111 # 不能改第一层的内存地址
# TypeError: 'tuple' object does not support item assignment
t[1]=222222222 # 不能改第一层的内存地址
# TypeError: 'tuple' object does not support item assignment
t[1][0]=11111111111111111 # 修改第二层的内存地址
print(t)
# (1, [11111111111111111, 22])
print(id(t[0]),id(t[1]))
# 1358874288 2579862236488
# 修改第二层的内存地址后第一层内存地址不变
3、类型转换: 所有能被for循环遍历的数据都能转换成元组,与列表的转换条件相同
print(tuple('hello'))
# ('h', 'e', 'l', 'l', 'o')
print(tuple([1,2,3]))
# (1, 2, 3)
print(tuple({'a1':111,'a2':333}))
# ('a1', 'a2')
print(tuple(range(10)))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
元组运算
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print (x,) | 1 2 3 | 迭代 |
元组内置方法
1、按索引取值(正向取+反向取)：只能取,不能修改,否则会报错
t=('aa','bbb','cc')
print(t[0])
# aa
print(t[-1])
# cc
2、切片(顾头不顾尾，步长):切片为索引附带的功能,本质为浅拷贝,并不在原数据上进行修改
t=('aa','bbb','cc','dd','eee')
print(t[0:3])
# ('aa', 'bbb', 'cc')
print(t[::-1])
# ('eee', 'dd', 'cc', 'bbb', 'aa')
3、长度: 元组内元素个数
t=('aa','bbb','cc','dd','eee')
print(len(t))
# 5
4、成员运算in和not in
t=('aa','bbb','cc','dd','eee')
print('aa' in t)
# True
5、循环: 遍历读取
for x in t:
print(x)
6、查找:index和count
t=(2,3,111,111,111,111)
print(t.index(111))
# 2
print(t.index(1111111111)) # index查找数据不存在时会报错
# ValueError: tuple.index(x): x not in tuple
print(t.count(111)) # 111出现的次数
# 4
五,字典
1、作用
字典可以用来存储含有描述性信息的数据,可读性比其他类型高,比如{"name":"wu","age":24}
它是以键值对的形式存储数据
2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是key必须是不可变类型,且不能重复
造字典的方式一 手写：
d={'k1':111,(1,2,3):222} # d=dict(...)
print(d['k1'])
# 111
print(d[(1,2,3)])
# 222
print(type(d))
# <class 'dict'>
d={} # 默认定义出来的是空字典
print(d,type(d))
# {} <class 'dict'>
造字典的方式二 dict()函数：
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>>
造字典的方式三:初始化一个字典
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" % str(dict))
新的字典为 : {'age': None, 'name': None, 'sex': None}
新的字典为 : {'age': 10, 'name': 10, 'sex': 10}
字典不能运算
字典内置方法
基础方法
1、按key存取值：可存可取
d={'k1':111}
# 针对赋值操作：如果key存在，则修改
d['k1']=222
# 针对赋值操作：如果key不存在，则创建新值
d['k2']=3333
print(d)
# {'k1': 222, 'k2': 3333}
2、长度len
d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(len(d))
# 4
3、成员运算in和not in:根据key
d={'k1':111,'k2':2222}
print('k1' in d)
# True
print(111 in d) # 只检测key
# False
4、删除
通用删除方法
d={'k1':111,'k2':2222}
del d['k1']
print(d)
pop删除：根据key删除元素，返回删除key对应的那个value值,如果要删除的 key 不存在，则需要添加默认值，否则会报错：
d={'k1':111,'k2':2222}
res=d.pop('k2')
print(d)
print(res)
dict1 = {1: "a", 2: [1, 2]}
print(dict1.pop(3,"nokey"),dict1) # 设置默认值，必须添加，否则报错
nokey {2: [1, 2]}
popitem删除：python2随机删除，python3删除最后一个,返回元组(删除的key,删除的value)
d={'k1':111,'k2':2222}
res=d.popitem()
print(d)
# {'k1': 111}
print(res)
# ('k2', 2222)
5 键值对items() ,键keys()，值values()
在python2中
d={'k1':111,'k2':2222}
d.keys()
['k2', 'k1']
d.values()
[2222, 111]
d.items()
[('k2', 2222), ('k1', 111)]
dict(d.items())
{'k2': 2222, 'k1': 111}
6、for循环使用
d={'k1':111,'k2':2222}
for k in d.keys():
print(k)
# k1
# k2
for k in d:
print(k)
# k1
# k2
for v in d.values():
print(v)
# 111
# 2222
for k,v in d.items():
print(k,v)
# k1 111
# k2 2222
print(list(d.keys()))
# ['k1', 'k2']
print(list(d.values()))
# [111, 2222]
print(list(d.items()))
# [('k1', 111), ('k2', 2222)]
常用方法
1、d.clear() 清空字典
d = {'k1': 111}
d.clear()
print(d)
# {}
2、d.update()
把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
d={'k1':111}
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d)
# {'k1': 111111111111111, 'k2': 222, 'k3': 333}
3、d.get() ：根据key取值，容错性好
d={'k1':111}
print(d['k2']) # key不存在则报错
# KeyError: 'k2'
print(d.get('k1'))
# 111
print(d.get('k2'))
# key不存在不报错，返回None
4、d.setdefault()
如果key有则不添加,返回字典的值
info = {"name": "wu"}
print(info.setdefault("name", "???"))
# wu
print(info)
# {'name': 'wu'}
如果key没有则添加，返回添加的值
info = {}
print(info.setdefault("name", "???"))
# ???
print(info)
# {'name': '???'}
5 values() 方法
values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("字典所有值为 : ", list(dict.values()))
字典所有值为 : ['female', 7, 'Zara']
6 copy()方法
copy() 函数返回一个字典的浅复制。
dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)
新复制的字典为 : {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}
六,集合
作用:集合可以进行独特的关系运算，对某些数据能做出去重的操作
1,集合的定义:
集合的形式是在{}内用逗号分隔开多个元素，并且这多个元素有以下三个特点
集合内元素必须为不可变类型
集合内元素无序
集合内元素不重复
s={} # 直接使用{}默认创建空字典
print(type(s))
# <class 'dict'>
# 定义空集合的方法
s=set()
print(s,type(s))
# set() <class 'set'>
s={1,2} # s=set({1,2})，集合的定义
s={1} # s=set({1})，集合的定义
# 集合内元素的3个特征
s={1,[1,2]} # 集合内元素必须为不可变类型
# TypeError: unhashable type: 'list'
s={1,'a','z','b',4,7} # 集合内元素无序
# 输出结果不同
s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)
# {1, 'a', 'b'}
2,类型转换(集合的创建)
所有能被for循环遍历的数据类型都能被转换成集合，但是有一个前提条件：这个数据内的元素必须都为不可变数据类型
res=set('hellolllll')
print(res)
# {'e', 'l', 'o', 'h'}
s = set(range(5))
print(s)
# {0, 1, 2, 3, 4}
print(set([1,1,1,1,1,1]))
# {1}
print(set([1,1,1,1,1,1,[11,222]]) # 报错
# TypeError: unhashable type: 'list'
print(set({'k1':1,'k2':2}))
# {'k2', 'k1'}
集合关系运算
取交集：等价于intersection() 方法
两者共同的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
res=friends1 & friends2
print(res)
# {'egon', 'jason'}
print(friends1.intersection(friends2))
# {'egon', 'jason'}
取并集：等价于union() 方法
两者所有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 | friends2)
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}
print(friends1.union(friends2))
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}
取差集：等价于difference() 方法
取friends1独有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 - friends2)
# {'zero', 'kevin'}
print(friends1.difference(friends2))
# {'zero', 'kevin'}
取friends2独有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends2 - friends1)
# {'Jy', 'ricky'}
print(friends2.difference(friends1))
# {'Jy', 'ricky'}
**对称差集: **
求两个用户独有的好友们（即去掉共有的好友）
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 ^ friends2)
# {'ricky', 'Jy', 'zero', 'kevin'}
print(friends1.symmetric_difference(friends2))
# {'ricky', 'Jy', 'zero', 'kevin'}
父子集：包含的关系
issuperset()与issubset()
s1={1,2,3}
s2={1,2,4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)
s1={1,2,3}
s2={1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是S2是s1的子集
print(s1.issuperset(s2)) # s1是父集
# True
print(s2.issubset(s1)) # s2是子集，s2 < s1 =>True
# True
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为子集
# True
print(s1.issuperset(s2))
# True
print(s2.issuperset(s1))
# True
集合去重
使用集合去重有两个注意点：
1,只能针对不可变类型去重
因为集合内不能存放不可哈希的数据类型，即集合内不能有可变数据类型的数据，所以集合的去重只能针对不可变类型去重。
print(set([1,1,1,1,2]))
# {1, 2}
print({1, 1, 1, [1, 1, 2]})
# TypeError: unhashable type: 'list'
2,无法保证原来的顺序
集合是一种无序的数据类型，所以去重后无法保证顺序相同
l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)
# [1, 2, 'b', 'z', 'a']
其他方法
长度 len
s1 = {1, 2, 3}
print(len(s1))
# 3
成员运算 in
s1 = {1, 2, 3}
print(1 in s1)
# True
循环遍历
s1 = {1, 2, 3}
for i in s1:
print(i)
删除元素 discard,remove,pop,clear
s1 = {1, 2, 3}
s1.discard(4)
# 不会报错
s1 = {1, 2, 3}
s1.remove(4)
# KeyError: 4
pop有返回值：删除的元素
s1 = {1, 2, 3}
res = s1.pop()
print(res)
# 1
print(s1)
# {2, 3}
clear() 方法用于移除集合中的所有元素。
fruits = {"apple", "banana", "cherry"}
fruits.clear()
添加元素：add
s1 = {1, 2, 3}
s1.add(4)
print(s1)
# {1, 2, 3, 4}
更新:update
s1 = {1, 2, 3}
s1.update({1, 3, 5})
print(s1)
# {1, 2, 3, 5}
不常用方法
是否独立：isdisjoint
s1 = {1, 2, 3}
res = s1.isdisjoint({3, 4, 5, 6})
# 两个集合有交集，则返回False
print(res)
res = s1.isdisjoint({4, 5, 6})
# 两个集合完全独立、没有共同部分，则返回True
print(res)
update
这个系列相当于在之前的功能上添加一个赋值操作
s = {1, 2, 3}
s.difference_update({3,4,5}) # s=s.difference({3,4,5})
print(s)
# {1, 2}
copy() 方法用于拷贝一个集合。
fruits = {"apple", "banana", "cherry"}
x = fruits.copy()
