字典dict
字典是由大括号{键:值}组成，字典是无序的，字典的键必须是不可变的数据类型，不能使用列表，集合等可变类型作为键。如下：
dict_1 = {'a':1} # 使用str为键，正确
dict_2 = {1:2} # 使用int为键，正确
dict_3 = {True:3} # 使用bool为键，正确
dict_4 = {('a',1):'a'} # 使用元组为键，正确
dict_5 = {[1,2]:'b'} # 使用list为键，错误
dict_6 = {{'a','b'}:12} # 使用set为键，错误
dict_7 = {{'a':1}:5} # 使用字典为键，错误
字典dict常用方法
setdefault(k[,d])：如果只给出键不给值，将打印键对应的值，如果没有找到键返回Note。如果给了键和值，如果键已存在，则什么都不做，如果没有找到键，则将键和值添加到字典中，如下示例：
dict_1 = {'a':1,'b':2}
# 添加一组键值对
dict_1.setdefault('c',3)
print(f'添加后的字典：{dict_1}')
# 添加键如果不指定值，默认是None
dict_1.setdefault('d')
print(f'添加后的字典：{dict_1}')
print('-'*40)
# 如果键不存在将返回None
print(f'字典中b的值是：{dict_1.setdefault("b")}')
print(f'字典中z的值是：{dict_1.setdefault("z")}')
# 打印内容如下
添加后的字典：{'a': 1, 'b': 2, 'c': 3}
添加后的字典：{'a': 1, 'b': 2, 'c': 3, 'd': None}
----------------------------------------
字典中b的值是：2
字典中z的值是：None
fromkeys(iterable, value=None, /)：给键添加一样的值，但需要注意，如果值是可变类型如列表，那么所有键将都指向这个列表，所以所有键的值都是一样的。
参数：
iterable：是一个可迭代对象，作为键。
value：键的值，默认是None。
示例：
dict_1 = {} dict_1 = dict.fromkeys(['b','c','d'],100) print(f'添加后的字典的键和值是：{dict_1}') print('-'*40) # 当键是一个可变的数据类型列表时 dict_1 = dict.fromkeys(['b','c','d'],[1,2]) print(f'添加后的字典的键和值是：{dict_1}') dict_1['b'].append(10) print(f'键b添加元素10后字典其它键和值是：{dict_1}')
# 打印内容如下 添加后的字典的键和值是：{'b': 100, 'c': 100, 'd': 100} ---------------------------------------- 添加后的字典的键和值是：{'b': [1, 2], 'c': [1, 2], 'd': [1, 2]} 键b添加元素10后字典其它键和值是：{'b': [1, 2, 10], 'c': [1, 2, 10], 'd': [1, 2, 10]}
pop(k[,d])：删除字典中的键值对，返回删除键对应的值。
参数：
k：要删除的键。
d：当键不存在的提示信息。
示例：
dict_1 = {'a':1,'b':2,'c':3,'d':4}
buf = dict_1.pop('a')
print(f'删除键a后的字典是：{dict_1}')
print(f'删除的值是：{buf}')
print('-'*40)
# 删除不存在的键 1
buf = dict_1.pop('z','字典中没有找到键z')
print(f'删除键a后的字典是：{dict_1}')
print(f'删除的值是：{buf}')
print('-'*40)
# 删除不存在的键 2，如果只给定pop只给定键不给提示信息则会报错
buf = dict_1.pop('z')
print(f'删除键a后的字典是：{dict_1}')
print(f'删除的值是：{buf}')
# 打印内容如下
删除键a后的字典是：{'b': 2, 'c': 3, 'd': 4}
删除的值是：1
----------------------------------------
删除键a后的字典是：{'b': 2, 'c': 3, 'd': 4}
删除的值是：字典中没有找到键z
----------------------------------------
Traceback (most recent call last):
File "C:Usersid_iotDesktop1.py", line 12, in <module>
buf = dict_1.pop('z')
KeyError: 'z'
pop(键,提示语句)是有返回值的，可以返回被删除的键的值。
popitem()：以元组的形式返回被删除的键值对，Python3.6以上版本删除最后一项键值对，其它版本是随机删除一组键值对。
dict_1 = {'a':1,'b':2,'c':3,'d':4}
buf = dict_1.popitem()
print(f'删除后的字典是：{dict_1}')
print(f'删除的值是：{buf}')
# 打印内容如下
删除后的字典是：{'a': 1, 'b': 2, 'c': 3}
删除的值是：('d', 4)
keys()：打印字典所有的键。
dict_1 = {'a':1,'b':2,'c':3,'d':4}
print(f'字典所有的键：{dict_1.keys()}')
print(f'字典所有的键(列表的形式)：{list(dict_1.keys())}')
# 打印内容如下
字典所有的键：dict_keys(['a', 'b', 'c', 'd'])
字典所有的键(列表的形式)：['a', 'b', 'c', 'd']
values()：打印字典所有的值。
dict_1 = {'a':1,'b':2,'c':3,'d':4}
print(f'字典所有的值：{dict_1.values()}')
print(f'字典所有的值(列表的形式)：{list(dict_1.values())}')
# 打印内容如下
字典所有的值：dict_values([1, 2, 3, 4])
字典所有的值(列表的形式)：[1, 2, 3, 4]
items()：打印字典所有的键值对。
dict_1 = {'a':1,'b':2,'c':3,'d':4}
print(f'字典的键和值：{dict_1.items()}')
print(f'字典的键和值(列表的形式)：{list(dict_1.items())}')
# 打印内如如下
字典的键和值：dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
字典的键和值(列表的形式)：[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
get(k[,d])：获取字典键的值。
参数：
k：字典的键。
d：提示信息。
示例：
dict_1 = {'a':1,'b':2,'c':3,'d':4}
print(f'字典键a的值：{dict_1.get("a")}')
print(f'字典键z的值：{dict_1.get("z")}')
print(f'字典键z的值：{dict_1.get("z","没有找到z")}')
# 打印内容如下
字典键a的值：1
字典键z的值：None
字典键z的值：没有找到z
copy()：字典的浅拷贝。
dict_1 = {'a':1,'b':2,'c':[1,2,3]}
temp = dict_1.copy()
dict_1['a'] = 10
print(f'更改dict_1键a的值后dict_1：{dict_1}')
print(f'更改dict_1键a的值后temp：{temp}')
print('-'*40)
dict_1['c'][0] = 10
print(f'更改dict_1键c的值后dict_1：{dict_1}')
print(f'更改dict_1键c的值后temp：{temp}')
# 打印内容如下
更改dict_1键a的值后dict_1：{'a': 10, 'b': 2, 'c': [1, 2, 3]}
更改dict_1键a的值后temp：{'a': 1, 'b': 2, 'c': [1, 2, 3]}
----------------------------------------
更改dict_1键c的值后dict_1：{'a': 10, 'b': 2, 'c': [10, 2, 3]}
更改dict_1键c的值后temp：{'a': 1, 'b': 2, 'c': [10, 2, 3]}
update(dic)：参数是一个字典，将dic更新到源字典中，如果dic的键在源字典中已存在，则更新源字典的键对应的值。
dict_1 = {'a':1,'b':2,'c':3}
# 向字典中添加{'d':4,'e':5}
dict_1.update({'d':4,'e':5})
print(f'更新后的字典是：{dict_1}')
# 更新字典键a,b的值
dict_1.update({'a':10,'b':20})
print(f'更新后的字典是：{dict_1}')
# 打印内容如下
更新后的字典是：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
更新后的字典是：{'a': 10, 'b': 20, 'c': 3, 'd': 4, 'e': 5}
clear()：清空字典。
dict_1 = {'a':1,'b':2,'c':3}
dict_1.clear()
print(dict_1)
# 打印内容如下
{}
解构
# 如果=号两边变量的数量和值的数量相等，那么变量的数据类型和值的数据类型相同 a,b,c = 1,2,3 print(a,b,c) # 如果用一个变量接收用逗号","分隔的多个值时，变量最终的数据类型是tuple元组 d = 1,2,3 print(d) # 打印内容如下 1 2 3 (1, 2, 3)
总结：如果=号两边变量的数量和值的数量相等，那么变量的数据类型和值的数据类型相同，如果用一个变量接收用逗号","分隔的多个值时，变量最终的数据类型是tuple元组。
通过解构的方式打印字典的键和值。
dict_ = {"电视剧":"水浒传","电影":"黄飞鸿"}
for key_,val_ in dict_.items(): # 通过结构的方式打印键和值
print(key_,val_)
# 打印内容如下
电视剧 水浒传
电影 黄飞鸿
set集合
集合是无序的因此不能循环获取，集合的特性是没有重复数据。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典的，还有set集合的值必须是不可变的如：整型、字符串、元祖不能是列表，字典等可被修改的数据。如下操作：
set_1 = {1,2,3} # 正确
set_2 = set() # 定义一个空列表
set_3 = {"a","b","c"} # 正确
set_4 = {True,False} # 正确
set_5 = {1,2,"a",(1,2,3)} # 正确
set_6 = {1,2,"a",[1,2,3]} # 错误的赋值方式,list是可变的
print(set_3)
# 打印内容如下:
TypeError: unhashable type: 'list'
set_7 = {1,2,"a",{"字典":"值"}} # 错误的赋值方式,dict是可变的
print(set_7)
# 打印内容如下:
TypeError: unhashable type: 'dict'
set_8 = {1,2,"a",{5,7,9}} # 错误的赋值方式,set是可变的
print(set_3)
# 打印内容如下:
TypeError: unhashable type: 'set'
set集合中常用的方法：
add()：向集合中添加数据，参数必须是不可改变的，参数类型参考set的赋值。
set_1 = {1,2,3}
set_1.add(4)
print(set_1)
# 打印内容如下
{1, 2, 3, 4}
update(可迭代对象)：向集合中添加可迭代数据。
set_1 = {1,2,3}
set_1.update('abc')
print(set_1)
set_1.update([4,5,6])
print(set_1)
# 打印内容如下
{1, 2, 3, 'c', 'b', 'a'}
{1, 2, 3, 4, 5, 'c', 6, 'b', 'a'}
del 删除集合。
set_1 = {1,2,3}
del set_1
print(set_1)
# 打印内容如下
Traceback (most recent call last):
File "C:Usersid_iotDesktop1.py", line 3, in <module>
print(set_1)
NameError: name 'set_1' is not defined
pop()：随机删除一个元素(测试如果有0，默认先删除0，其它随机)。
set_1 = {5,2,1,0,4}
set_1.pop()
print(f'pop后的set_1的值：{set_1}')
set_2 = {'c','a','b','d'}
set_2.pop()
print(f'pop后的set_2的值：{set_2}')
# 打印内容如下
pop后的set_1的值：{1, 2, 4, 5}
pop后的set_2的值：{'b', 'c', 'a'}
remove(元素)：根据元素进行删除，如果删除一个没有的元素会报错。
set_1 = {1,2,3}
set_1.remove(1)
print(set_1)
# 删除一个没有的元素
set_1.remove(10)
# 打印内容如下
{2, 3}
Traceback (most recent call last):
File "C:Usersid_iotDesktop1.py", line 5, in <module>
set_1.remove(10)
KeyError: 10
copy()：集合的浅拷贝。
set_1 = {1,2,3}
temp = set_1.copy()
print(temp)
# 打印内容如下
{1, 2, 3}
clear()：清空集合。
set_1 = {1,2,3}
set_1.clear()
print(set_1)
# 打印内容如下
set()
集合的其它操作
交集：两个集合里面都存在的数据，可以使用&或者使用函数intersection来获取两个集合的交集。
set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 & set_2 # 通过&符号获取set_1和set_2的交集
print(set_3)
# 打印内容如下:
{2, 3}
# 通过函数intersection()获取交集
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.intersection(set_2) # 通过函数获取set_1和set_2的交集 print(set_3)
# 打印内容如下:
{'a', 'c'}
并集：将两个集合进行合并(集合是去重复的)，使用|符号或者使用union()函数。
set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 | set_2 # 使用|符号获取两个集合的并集
print(set_3)
# 打印内容如下:
{1, 2, 3, 4, 40, 10}
# 通过函数union()获取两个集合的并集
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.union(set_2) # 使用union()函数获取两个数的并集
print(set_3)
# 打印内容如下:
{'b', 'z', 'a', 'c', 'd'}
差集：从第一个集合中减去第一个集合和第二个集合共同存在的元素，使用符号-或者使用函数difference()来实现。
set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 - set_2 # 通过符号-将set_1和set_2共同存在的元素从set_1中删除,如果set_2在前就从set_2中删除
print(set_3)
# 打印内容如下:
{1, 4}
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.difference(set_2) # 通过函数difference()实现
print(set_3)
# 打印内容如下:
{'d', 'b'}
反交集：将两个集合进行合并，并去除相同的元素，使用符号^或者symmetric_difference。
set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 ^ set_2 # 使用^符号实现
print(set_3)
# 打印内容如下:
{1, 4, 40, 10}
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.symmetric_difference(set_2) # 使用函数实现
print(set_3)
# 打印内容如下:
{'z', 'b', 'd'}
子集：一个集合是否被另一个集合所包含，如果被另一个集合包含返回True，否则返回False，使用<符号或者issubset()。
set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 < set_2 # 使用<符号实现
print(set_3)
# 打印内容如下:
False
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a","b","d","e"}
set_3 = set_1.issubset(set_2) # 使用函数实现
print(set_3)
# 打印内容如下:
True
超级：与子集相反，判断一个集合是否包含另一个集合，如果包含另一个集合返回True否则返回False，使用符号>或者issuperset()。
set_1 = {1,2,3,4,10,50,40}
set_2 = {10,2,40,3}
set_3 = set_1 > set_2 # 使用>符号
print(set_3)
# 打印内容如下:
True
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a","b","d","e"}
set_3 = set_1.issuperset(set_2) # 使用函数实现
print(set_3)
# 打印内容如下:
False
frozenset(可迭代对象)：返回一个冻结的集合，被冻结的集合不能进行修改，删除，添加等操作，如果不写参数，则返回一个冻结的空的集合，参数是可迭代对象所以可以是列表，字典等
下面是一些简单的事例：
set_1 = {"a","b","c","d"}
dic_1 = {"字典":"值"}
list_1 = [1,2,3]
set_2 = frozenset(set_1)
dic_2 = frozenset(dic_1)
list_2 = frozenset(list_1)
print(type(set_2),set_2)
print(type(dic_2),dic_2) # 字典只能看键不能看值,很多方法都不能用
print(type(list_2),list_2) # 列表的下标也不能使用,大多数函数不能用
# 打印内容如下:
<class 'frozenset'> frozenset({'b', 'd', 'a', 'c'})
<class 'frozenset'> frozenset({'字典'})
<class 'frozenset'> frozenset({1, 2, 3})
下一篇：编码，解码，小数据池：https://www.cnblogs.com/caesar-id/p/10252202.html