列表类型内置方法
作用
存储多个任意数据类型的元素
定义方式
“[ ]”内用逗号隔开多个任意数据类型的元素
hobby = ['run',1,2.3,'read','swimming','fishing']方法
索引取值（既可取也可以改）
a = hobby[3]
hobby[0] = 'xiaoming'
print(a)
print(hobby)read
['xiaoming',1,2.3,'read','swimming','fishing']
切片
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list[0:3:2]: {name_list[0:3:2]}")name_list[0:3:2]: ['nick', 'tank']
长度
print(len(name_list))4
成员运算in和not in
print('xiaoming' in name_list)
print('xiaoming' not in name_list)False
True
追加值
name_list.append('zhao')
print(name_list)['nick', 'jason', 'tank', 'sean', 'zhao']
删除
del name_list[2]
print(name_list)['nick', 'jason', 'sean']
循环
for name in name_list:
print(name)nick
jason
tank
sean
多个值or一个值
多个值
有序or无序
有序
可变or不可变
可变
元祖类型内置方法
作用
类似于列表，可以取不可以存
定义方式
friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')方法
索引取值（无法更改）
name_tuple = ('nick','jason','tank','sean')
print(name_tuple[0])nick
切片（顾头不顾尾，步长）
print(name_tuple[1:3:2])('jason',)
长度
print(len(name_tuple))4
成员运算
print('nick' in name_tuple)True
for循环
for name in name_tuple:
print(name)nick
jason
tank
sean
count()
print(name_tuple.count('nick'))1
index()
print(name_tuple.index('nick'))0
多个值or一个值
多个值
有序or无序
有序
可变or不可变
无可变和不可变之说
字典类型内置方法
作用
存多个值，但每一个值都有一个key与之对应，key对值有描述功能。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。
值太多列表存容易，取麻烦时使用字典。
定义方式
’‘{ }“内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。
方法
按key取值：可存可取
dic = {'a':1,'b',2}
print(dic['a'])
dic['a'] = 3
print(dic('a'))1
3
长度len
print(len(dic))2
成员运算in和not in
print('a' in dic)
print(1 in dic)True
False
删除
del dic['a']
print(dic.get('a'))None
dic.pop('a')
print(dic.pop('b')) # 随机删除指定的元素，打印删除的值
print(dic.get('a'))2
None
priny(dic.popitem()) # 随机删除一个键值对，打印删除的值('b',2)
键keys()、值values()、键值对items()
print(dic.keys())
print(dic.values())
print(dic.items())dict_keys(['a','b'])
dict_values([1,2])
dict_items([('a',1),('b',2)])
循环
for k,v in dic.items():
print(k,v)a 1
b 2
多个值or一个值
多个值
有序or无序
无序
可变or不可变
可变
集合类型内置方法
作用
存多个值，为了集合之间做运算。
集合内元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
定义方式
s = set()
s1 = {1,2,3,4,5}方法
长度
s = {1,2,'a'}
print(len(s))3
成员运算in和not in
print(1 in s)True
|并集
pythoners = {'jason','nick','tank','sean'}
linuxers = {'nick','egon','kevin'}
print(pythoners|linuxers) # 对应方法pythoners.union(linuxers){'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
&交集
print(pythoners&linuxers) # 对应方法pythoners.intersection(linuxers){'nick'}
-差集
print(pythoners-linuxers) # 对应方法pythoners.difference(linuxers){'tank', 'jason', 'sean'}
^对称差集
print(pythoners^linuxers) # 对应方法pythoners.symmetric_difference(linuxers){'egon', 'tank', 'kevin', 'jason', 'sean'}
==
javers = {'nick','egon','kevin'}
print(pythoners==linuxers)
print(linuxers==javers)False
True
父集：>、>=
java = {'jason','nick'}
print(pythoners>linuxers)
print(pythoners>=linuxers)
print(pythoners>=java)
print(pythoners.issuperset(java))False
False
True
True
子集：<、<=
print(pythoners<linuxers)
print(pythoners<=linuxers)
print(java.issubset(java))False
False
True
多个值or一个值
多个值
有序or无序
无序
可变or不可变
可变
布尔类型
一般用于判断，除了0/None/空/False自带布尔值为False，其他的数据类型自带布尔值为True
数据类型总结
| 一个值 | 多个值 |
|---|---|
| 整型/浮点型/字符串 | 列表/元祖/字典/集合 |
| 有序 | 无序 |
|---|---|
| 字符串/列表/元祖 | 字典/集合 |
| 可变 | 不可变 |
|---|---|
| 列表/字典/集合 | 整型/浮点型/字符串 |
拷贝
拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的
l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = l1
l1.append('g')
print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']，'g']如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变
浅拷贝
import copy
l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']]
l1[3].append('g')
print(l1) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变
深拷贝
import copy
l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']]
l1[3].append('g')
print(l1) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']]
如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化