Python字典、集合之高山流水

字典dict
字典是由大括号{键:值}组成、字典是无序的、字典的键必须是不可变数据类型、不能使用列表作为键，但可以使用元祖作为字典的键。例如：

dict_ = {"test":"Hello World"}

str_ = "hello"
dict_ = {str_:"霍元甲"}      # 这是正确的

list_ = [1,2,3]
dict_ = {list_:"西游记"}     # 这是错误的

tuple_ = (1,2,3)
dic = {tuple_:"红楼梦"}      # 这是正确的

dict_ = {1:"陈真"}           # 这是正确的

dict_ = {True:"霍东阁"}      # 这是正确的

dict_1 = {"字典":"值"}
dict_ = {dict_1:"三国演义"}   # 这是错误的

新增

setdefault(键,值)：如果只写键不写值将打印该键所对应的值，如果没有找到键返回Note。

dict_ = {"电视剧":"笑傲江湖"}
dict_["电影"] = "黄飞鸿"

dict_.setdefault("新增","我是新增的")  # setdefault()函数添加键值对
print(dict_)
# 打印如下内容:
{'电视剧': '笑傲江湖', '电影': '黄飞鸿', '新增': '我是新增的'}

# 如果setdefault(键)如果只写键不写值是查询键的值.
print(dict_.setdefault("新增"))

# 打印如下内容:
我是新增的 

fromkeys(字典键列表,值)：如果值是列表，是可变的，那么如果更改列表中的值会影响整个字典键中的值。

dict_ = {}
list_str = ["name","age"]
dict_ = dict_.fromkeys(list_str,[1,2,3])
dict_["name"].append(4)    # 向dict_["name"]中追加元素4                                            
print(dic)

# 打印内容如下:
{'name': [1, 2, 3, 4], 'age': [1, 2, 3, 4]}     # 发现修改name键的值后,age键的值也发生了改变,和name键的值一样

可以通过重新给键赋值的方法，摆脱更改键中的值，而影响整个字典中键的值。

dic={}
s = ["name","age"]
dic = dic.fromkeys(s,[1,2,3])
dic["name"] = [10,2]   # 给键"name"重新赋值
print(dic)

# 打印内容如下:
{'name': [10, 2], 'age': [1, 2, 3]}

删除

pop(键)：删除字典中的键值对。

dict_ = {"电视剧":"西游记","电影":"少林寺"}
print(dict_.pop("test"))  # pop()如果找不到键会报错

# 打印内容如下:
KeyError: 'test'     # 没有找到键

 给pop(键,提示信息)：添加个参数，用于在没有找到键时提示给用户。

dict_ = {"电视剧":"西游记","电影":"少林寺"}
print(dict_.pop("test","没有找到该键"))  # 可以在pop(键,提示信息)

# 打印内容如下:
没有找到该键       # 用于提示用户这个键没有找到.

pop(键,提示语句)是有返回值的，可以返回被删除的键的值。

 

dict_ = {"电视剧":"西游记","电影":"少林寺"}
ret = dict_.pop("电视剧")
print(dict_)
print("被删除的值是：",ret)

# 打印内容如下
{'电影': '少林寺'}
被删除的值是： 西游记

 

popitem():没有参数，返回值是被删除的键值对，Python3.6以上版本删除最后一项键值对，其它版本是随机删除一组键值对。

 

dict_ = {"电视剧":"西游记","电影":"少林寺"}
ret = dict_.popitem()
print(dict_)
print("被删除的键值对是：",ret)

# 打印内容如下
{'电视剧': '西游记'}
被删除的键值对是： ('电影', '少林寺')

 

查找

keys()：打印字典所有的键。

dict_ = {"电视剧":"霍元甲","电影":"黄飞鸿"}
print(dict_.keys())

# 打印内容如下:
dict_keys(['电视剧', '电影'])

values()：打印字典所有的值。

dict_ = {"电视剧":"霍元甲","电影":"黄飞鸿"}
print(dict_.values())

# 打印内容如下:
dict_values(['霍元甲', '黄飞鸿'])

items()：打印字典所有的键值对。

dict_ = {"电视剧":"霍元甲","电影":"黄飞鸿"}
print(dict_.items())

# 打印内容下:
dict_items([('电视剧', '霍元甲'), ('电影', '黄飞鸿')])

由keys()、values()、items()的打印结果看，可能不是我们想要的。如果我们想要字符串需要进行如下转换：

 

dict_ = {"电视剧":"霍元甲","电影":"黄飞鸿"}
list_key = list(dict_.keys())  # 将键先转换成列表
str_ = " ".join(list_key)      # 将列表转换成字符串
print("list_key:",list_key,"str_key:",str_)

list_value = list(dict_.values())  # 将值先转换成列表
str_ = " ".join(list_value)   # 将列表转换成字符串
print("list_value:",list_value,"str_value:",str_)

list_item = list(dict_.items())
print("list_item:",list_item)

# 打印内容如下
list_key: ['电视剧', '电影'] str_key: 电视剧 电影
list_value: ['霍元甲', '黄飞鸿'] str_value: 霍元甲 黄飞鸿
list_item: [('电视剧', '霍元甲'), ('电影', '黄飞鸿')]

 

解构(常用操作)

a,b,c = 1,2,3
str_1,str_2 = "a","b"
list_1,list_2 = [1,2,3],["a","b","c"]
dict_1,dict_2 = {"电视剧":"上海滩"},{"电影":"黄飞鸿"}

print("a,b,c:",a,b,c,type(a),type(b),type(c))
print("str1,str2:",str_1,str_2,type(str_1),type(str_2))
print("list_1,list_2:",list_1,list_2,type(list_1),type(list_2))
print("dict_1,dict_2:",dict_1,dict_2,type(dict_1),type(dict_2))

# 打印内容如下:
a,b,c: 1 2 3 <class 'int'> <class 'int'> <class 'int'>
str1,str2: a b <class 'str'> <class 'str'>
list_1,list_2: [1, 2, 3] ['a', 'b', 'c'] <class 'list'> <class 'list'>
dict_1,dict_2: {'电视剧': '上海滩'} {'电影': '黄飞鸿'} <class 'dict'> <class 'dict'>

# 我们发现变量的数据类型和值的类型相同

 

buf = 1,2,3
buf_1 = "a","b","c"
buf_2 = [1,2,3],["a","b","c"]
buf_3 = {"电视剧":"上海滩"},{"电影":"黄飞鸿"}

print("buf:",buf,type(buf))
print("buf_1:",buf_1,type(buf_1))
print("buf_2:",buf_2,type(buf_2))
print("buf_3:",buf_3,type(buf_3))

# 打印结果如下
buf: (1, 2, 3) <class 'tuple'>
buf_1: ('a', 'b', 'c') <class 'tuple'>
buf_2: ([1, 2, 3], ['a', 'b', 'c']) <class 'tuple'>
buf_3: ({'电视剧': '上海滩'}, {'电影': '黄飞鸿'}) <class 'tuple'>

# 我们发现所有变量的数据类型都是元组tuple

 总结：如果=号两边变量的数量和值的数量相等，那么变量的数据类型和值的数据类型相同，如果用一个变量接收用逗号","分隔的多个值时，变量最终的数据类型是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,2,3}
set_.add(4)
print(set_)

#打印如下内容:
{1, 2, 3, 4}

 

set_ = {1,2,3}
list_ = ["a","n"]

set_.add(list_)   # 因为列表是可变的,所以不能用作集合的值

# 打印内容如下:
TypeError: unhashable type: 'list'

更新

update(可迭代对象)：向集合中添加可迭代数据。

set_1 = {1,2,"a"}
set_1.update([10,20,3])
set_1.update(("defghigk"))
set_1.update((10,20,30))
set_1.update({"字典":"键"})
print(set_1)

# 打印内容如下
{1, 2, 3, 10, 'g', 'h', 'd', 'a', 'i', 'k', 20, 'f', 'e', '字典', 30}

删除：

set_3 = {1,2,"a"}
del set_3   # 因为集合是无序的没有下标,所以用del只能删除集合

pop()：随机删除一个元素(测试如果有0，默认先删除0，其它随机)

set_3 = {1,2,"a"}
set_3.pop()     # 随机删除一个元素
print(set_3)

# 打印内容如下:
{2, 'a'}

remove(元素):根据元素删除元素,如果删除一个没有的元素会报错

set_3 = {1,2,"a"}
set_3.remove(2)
print(set_3)

# 打印内容如下:
{1, 'a'}

集合的其它操作:
交集:两个集合里面都存在的数据,可以使用&或者使用函数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})