Python容器数据类型（字典、集合）
容器类型的进阶使用（字典、集合）
字典的相关函数
| 函数 | 作用 |
|---|---|
| fromkeys | 批量创建键值对，并设置默认值 |
| pop | 指定键删除指定的键值对，返回指定键对应的值。 |
| popitem | 删除最后一个键值对，以元组的形式返回被删除的键值对。 |
| clear | 清空字典，返回None |
| update | 批量更新 |
| get | 查找数据， 获取指定键的值 |
| keys | 将字典中的键组成新的可迭代对象 |
| values | 将字典中的值祖晨新的可迭代对象 |
| items | 将字典中的键值对凑成一个个元组，组成一个新的可迭代对象 |
fromkeys
将一个容器中的全部元素都作为字典的键，并设置默认值，批量的创建键值对
lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, None)
print(dct) # {'key0': None, 'key1': None, 'key2': None} 但是我们要注意一个问题，因为这些键值对的值都是来自于同一个内存地址当中的，如果我们设置的默认值是一个可变的数据类型的话，那么修改其中的一个值，所有的键值的值都会发生改变，这是灾难性的。
lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, [1])
print(dct) # {'key0': [1], 'key1': [1], 'key2': [1]}
# 我们只是修改了key0的值，但是整个所有使用fromkeys创建的数据全部被修改了
dct['key0'][0] = 2
print(dct) # {'key0': [2], 'key1': [2], 'key2': [2]} 所以我们一般的情况下可以设置默认值为None，因为None默认开辟一个小数据池的地址，永远不会发生变化，且None表示什么也没有，对于内存地址的占用是独一致的，当None变成任何的数据类型的时候，都不用担心其它的None也一起修改。类似的数据类型还有1、2等数字类型，这些数据类型的特点就是具有内存的缓存机制作为保护。
详情可见，内存的缓存机制。
lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, None)
print(dct) # {'key0': None, 'key1': None, 'key2': None}
dct['key0'] = 'msr20666'
print(dct) # {'key0': 'msr20666', 'key1': None, 'key2': None} pop
通过键删除指定的键值对，如果没有该键就会报错，但是可以设置默认值，防止找不到指定键而报错。
# 指定key0键删除
dct = {'key0': None, 'key1': None, 'key2': None}
dct.pop('key0')
print(dct) # {'key1': None, 'key2': None}
# 指定key4键删除，但是没有该键，报错
# dct.pop('key4') # error
# 指定默认值，预防报错
res = dct.pop('key4', '没有该键')
print(dct) # {'key1': None, 'key2': None}
print(res) # 没有该键 popitem
删除最后一个键值对。
dct = {'one': 1, 'two': 2, 'three': 3}
dct.popitem()
print(dct) # {'one': 1, 'two': 2} clear
清空字典
dct = {'one': 1, 'two': 2, 'three': 3}
dct.clear()
print(dct) # {} update
用来批量的更新字典的键，如果这键存在就更新对应的值，如果这个键不存在，就创建一个新的键值对。
# 方式一：定义一组新的字典，然后将新字典跟新至旧的字典当中（推荐使用）
dct = {'one': 1, 'two': 2, 'three': 3}
new_dct = {'one': 11, 'two': 22, 'six': 666}
dct.update(new_dct)
print(dct) # {'one': 11, 'two': 22, 'three': 3, 'six': 666}
# 方式二：在函数中直接跟着更新键值对（不推荐使用）
'''
在函数当中的直接使用关键字参数进行字典键值对的更新，关键字表示键，对应的值就是值；
缺点是关键字的命名和变量的命名是一样的，比如不能使用数字开头，那么如果字典键是整型那么就不能修改它对应的值了。
'''
dct = {1:1, 2:2, 'one':1, 'two':2}
# 关键字的命名不能使用数字开头，那么就无法修改键是整型的键值对
# 所以这也是推荐是按照变量名的标准去命名键名的原因之一
# dct.update(1=1) # error
dct.update(one=11)
print(dct) # {1: 1, 2: 2, 'one': 11, 'two': 2}
# 可以一次性修改多个值
dct.update(one=111, two=22, three=33)
print(dct) # {1: 1, 2: 2, 'one': 111, 'two': 22, 'three': 33} get
查找数据，指定一个键获取对应的值
dct = {'one': 1, 'two': 2, 'three': 3}
# 指定键获取数据
res = dct.get('one')
print(res) # 1
# 如果没有这个键，就返回None
res = dct.get('six')
print(res) # None
# 可以设置默认值，如果查不到数据就返回设置的默认值
res = dct.get('six', '没有找到这个键')
print(res) # 没有找到这个键
# 也可以直接指定键来查看对应的数据，但是如果没有这个键就会直接报错
# res = dct['six'] # error 找不到该数据 keys
将字典的键组成一个叫做
dict_keys dct = {'one': 1, 'two': 2, 'three': 3}
res = dct.keys()
print(res) # dict_keys(['one', 'two', 'three'])
print(type(res)) # <class 'dict_key values
将字典中的值组成一个叫做
dict_values dct = {'one': 1, 'two': 2, 'three': 3}
res = dct.values()
print(res) # dict_values([1, 2, 3])
print(type(res)) # <class 'dict_values'> items
将字典中的键值对凑成一个个的元组，组成叫做
dict_items dct = {'one': 1, 'two': 2, 'three': 3}
res = dct.items()
print(res) # dict_items([('one', 1), ('two', 2), ('three', 3)])
print(type(res)) # <class 'dict_items'> 集合的相关函数
| 函数 | 作用 |
|---|---|
| add | 向集合中添加数据，一次只能添加一个， 返回None |
| update | 向集合中迭代添加数据，一次可以添加多个，返回None |
| pop | 随机删除集合中的一个数据，返回被删除的值 |
| remove | 删除集合中指定的一个值，如果这个值不存在就报错，返回None |
| discard | 删除集合中指定的一个值，如果这个值不存在也不会报错，返回None |
| clear | 清空集合 |
| intersection | 返回交集 |
| difference | 返回差集 |
| union | 返回并集 |
| symmetric_difference | 返回对称差集或者是补集 |
| issuperset | 判断是否是指定集合的父集 |
| issubset | 判断是否是指定集合的子集 |
| isdisjoint | 判断两个集合是否不相交（） |
| frozenset | 将容器强转成为冰冻集合类型 |
集合的增删改查
集合是无序数据，因此不能进行查找和修改操作；
add
往集合中单个的添加数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.add('motherland')
print(setvar) # {1, 2, 3, 'motherland', 'hello', 'msr20666', 'msr'} update
迭代的添加数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
lst = ('china', 'america', 'russia')
setvar.update(lst)
print(setvar) # {1, 2, 3, 'msr', 'america', 'russia', 'china', 'hello', 'msr20666'} pop
随机的删除其中的一个数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.pop()
print(setvar) # {2, 3, 'msr', 'msr20666', 'hello'} remove
删除集合中指定的一个值，如果这个值不存在，就会报错
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.remove('hello')
print(setvar) # {1, 2, 3, 'msr', 'msr20666'}
setvar.remove(4) # error，这个值不存在 discard
删除集合中指定的一个值，如果这个值不存在也不会报错
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.discard('hello')
print(setvar) # {1, 2, 3, 'msr20666', 'msr'}
res = setvar.discard(4)
print(res) # None clear
清空集合
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.clear()
print(setvar) # set() 集合的交叉并补
intersection
交集，就是两个集合中相同的数据，两个集合的交集是相同的，简写 &
set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}
res = set0.intersection(set1)
print(res) # {1, 2, 3}
res = set1 & set0
print(res) # {1, 2, 3} difference
差集，差集就是两个集合当中不相同的数据，注意两个集合中的差集是不同的，简写 -
set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}
res = set0.difference(set1)
print(res) # {4, 5, 6}
res = set1 - set0
print(res) # {0, 8, 9, 7} union
并集，是两个集合的所有数据，但是交集部分只会存在一个，两个集合的并集是相同的，简写使用 |
set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}
res = set0.union(set1)
print(res) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
res = set1 | set0
print(res) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} symmetric_difference
对称差集，是两个集合中除去并集的数据，就是两者的差集，两者的对称差集是相同的，简写使用 ^
set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}
res = set0.symmetric_difference(set1)
print(res) # {0, 4, 5, 6, 7, 8, 9}
res = set1 ^ set0
print(res) # {0, 4, 5, 6, 7, 8, 9} 补集，如果两个集合，其中的一个集合包含另一个集合的所有数据，那么这个集合就是另一个集合的父集，反之就是子集，父集当中子集不存在的数据就是子集的补集
set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}
res = set0.symmetric_difference(set1)
print(res) # {8, 5, 6, 7}
res = set1.symmetric_difference(set0)
print(res) # {5, 6, 7, 8} issuperset
判断是否是指定集合的父集，返回布尔值，简写使用
>=+ set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}
res = set0.issuperset(set1)
print(res) # True
res = set1 > set0
print(res) # False
res = set1 >= set0
print(res) # False issubset
判断是否是指定集合的子集，返回布尔值，简写使用
<<= set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}
res = set0.issubset(set1)
print(res) # False
res = set1 < set0
print(res) # True
res = set1 <= set0
print(res) # True isdisjoint
检测两个集合是否不相交
set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}
res = set0.isdisjoint(set1)
print(res) # False
set0 = {1, 2, 3}
set1 = {4, 5, 6}
res = set0.isdisjoint(set1)
print(res) # True 冰冻集合
冰冻集合可以理解为将集合冰冻封印，这样集合不能进行添加删除元素等操作，只能进行交叉并补的操作。
setvar = {1, 2, 3, 4}
lstvar = [1, 2, 3, 4, 5]
fzs0 = frozenset(setvar)
print(fzs0) # # frozenset({1, 2, 3, 4})
print(type(fzs0)) # <class 'frozenset'>
fzs1 = frozenset(lstvar)
print(fzs1) # frozenset({1, 2, 3, 4, 5})
print(type(fzs1)) # <class 'frozenset'> 冰冻集合不能进行增删改查的操作
fzs0.clear() # error 可以进行关于交叉并补的操作
res = fzs0.issuperset(fzs1)
print(res) # False 冰冻集合没有解冻的方法，但是可以转换成为其它的数据类型，比如使用set函数将冰冻集合变成普通的集合。
lst = set(fzs1)
print(setvar) 集合交叉并补的简写为什么是运算符
简单的来说，交叉并补和位运算的本质都是一样的。
| 交叉并补 | 位运算 | 符号 | 相同之处 |
|---|---|---|---|
| 交集 | 按位与 | & | 两者之间共同存在的保留下来 |
| 并集 | 按位或 | | | 两者之间的全部保留下来 |
| 对称差集 | 按位异或 | ^ | 除了都有的，其它的保留下来 |