元组，字典和集合
文章目录
元组，字典和集合元组（tuple）元组的创建元组的解包
字典（dict）字典的创建查询字典里的值（value）字典的使用len()修改键的值增加删减更新字典get()
集合（set）集合的创建集合的使用add(x)remove(x)pop()clear()update(集合)
集合的运算&（交集运算）|（并集运算）-（差集运算）^（异或集）<(<=)和>(>=)
元组（tuple）
元组是一个不可变序列，一般当我们不希望存储的数据改变时，我们使用元组，其他情况一般使用列表。
# tup = (1,2,4,5,6)
# tup[3] = 12 #TypeError: 'tuple' object does not support item assignment
# print(tup)
元组的创建
# tup = (1,2,4,5,6)
# tup = 1,2,3,4,5
# tup = 10, # 当元组不为空时，里面至少有一个逗号
# print(tup,type(tup))
元组的解包
# 需要与元组元素个数相同的变量
# tup = (1,2,3,4,5)
# a,b,c,d,e = tup
# a,b = tup #ValueError: too many values to unpack
# print(a,b)
# 在变量前面加上*号，可以使多个元组的元素值赋予这个变量，以列表的形式
# a,b,*c = tup
# a,*b,c = tup
# *a,b,c = tup
# print(a,b,c)
字典（dict）
字典是可变序列，与列表类似都是存储数据的容器，字典的存储性能较差，查询性能较好，与列表相反字典是一种映射结构，字典里每个值（value）都有唯一的一个名字对应，通过找到这个名字就可以访问值；我们称这个名字为键（key）字典里的每一项都有键值对组成（key-value），因此我们又称字典为键值对结构字典里的值可以是任何对象，字典的键可以是任何不可变对象字典的键是唯一的，如果出现重复地，后面出现的会覆盖前面的
字典的创建
# dct = {'name':'Sleet','age':19,'gender':'男'}
# 如果字典里的项较多，为方便阅读，通常如下写法
# dct = {
# 'name':'Sleet',
# 'age':19,
# 'gender':'男'
# }
# dct = dict(name='Sleet',age=19,gender='男')
# dct = dict([('name','Sleet'),('age',19),('gender','男')])
# print(dct)
查询字典里的值（value）
# dct = {'name':'Sleet','age':19,'gender':'男'}
# print(dct['name'])
# key = 'name'
# print(dct[key])
字典的使用
len()
# dct = {'name':'Sleet','age':19,'gender':'男'}
# 返回字典长度
# print(len(dct))
修改键的值
# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct['name'] = 'Jerry'
# dct['hobby'] = 'basketball' # 如果修改的键不存在，则自动进行创建
增加
# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct['hobby'] = 'basketball'
# r = dct.setdefault('hobby','basketball') # 有返回值，返回值为键值对的值
# dct.setdefault('name','Jerry') # 如果字典中存在该键，则不进行任何操作
删减
# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct.popitem() # 随机删除字典中的一项（一般都是从后面开始删除）
# dct.popitem() # {'name': 'Sleet', 'age': 19}
# r = dct.popitem() # 有返回值，返回值的形式为元组，返回的是双值子序列
# pop() # 通过key来删除项
# dct.pop('name')
# r = dct.pop('hobby','没有这个键') # 如果不存在键，可以返回第二个参数
# r = dct.pop('name') # 有返回值，返回值为键值对的值
# clear() # 清空字典
# dct.clear()
# del dct['name'] # 用关键字进行删除
更新字典
# dct = {'name':'Sleet','age':19,'gender':'男'}
# update(字典) # 用另一个字典来更新当前字典
# dct_1 = {
# 'name':'Jerry',
# 'hobby_1':'basketball',
# 'hobby_2':'tennis',
# 'hobby_3':'badminton'
# }
# dct.update(dct_1) # 如果更新的字典里有与原字典重名的键，则更新后会进行覆盖
# print(dct)
get()
# 根据键来获取字典的值，第二个参数可以指定一个值，当获取不到值的时候返回这个值，默认为None
# value = dct.get('name')
# value = dct.get('hobby')
# value = dct.get('hobby','没有这个键')
# print(value)
集合（set）
集合与列表类似
不同点：
集合存储的对象是不可变的集合里的元素是无序的（不是按照插入的顺序进行排序）集合的对象是不能重复的
集合的创建
# 集合的创建
# s = {1,2,3,4,5}
# s = set([1,2,3,4,5])
# s = set('hello') # 无重复元素
# s = set(1,2,3) # TypeError: set expected at most 1 argument, got 3
# s = set(1) # TypeError: 'int' object is not iterable
# s = {100,10,1,2,3,4} # 无序
# s = {1,1,2,3,4,4} # 元素不重复
# print(s)
可以通过s = {1,2,…}创建；注意：当s = {}时创建的是空的字典可以通过s = set()创建；如果没有传递参数，则返回set()，这就是空集合；set()传递的参数只能有一个，而且必须是可迭代的对象
集合的使用
add(x)
add(x)：在集合中增加一个元素
# s = {1,2,3,4,5}
# s.add(6)
# print(s)
remove(x)
remove(x)：删除集合中的指定元素
# s = {1,2,3,4,5}
# s.remove(5)
# print(s)
pop()
pop()：随机删除集合中的一个元素，有返回值，返回被删除的元素
# s = {'a','b','c','d',1,2,3,4,}
# r = s.pop()
# print(r)
# print(s)
clear()
clear()：清空集合
# s = {'a','b','c','d',1,2,3,4,}
# s.clear()
# print(s)
update(集合)
用另一个集合更新当前集合
# s = {'a','b','c','d',1,2,3,4,}
# s2 = set('python')
# s.update(s2)
# print(s)
# print(s2)
集合的运算
&（交集运算）
# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 & s2
# print(r)
|（并集运算）
# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 | s2
# print(r)
-（差集运算）
# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 - s2
# print(r)
^（异或集）
# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 ^ s2
# print(r)
<(<=)和>(>=)
a<b：a是b的真子集a<=b：a是b的子集a>b：a是b的真超集a>=b：a是b的超集
# s3 = {1,2,3,4}
# s4 = {1,2,3,4}
# s5 = {1,2,3,4,5}
# print(s3<=s4)
# print(s3<s4)
# print(s3<s5)
以上内容为个人总结+资料查找 欢迎各位批评指正~
