Python字典、集合之高山流水

字典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:\Users\id_iot\Desktop\1.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:\Users\id_iot\Desktop\1.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:\Users\id_iot\Desktop\1.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