Python中字典和集合

字典

Python字典可存储任意类型对象，如字符串、数字、元组…… 优点：取值方便，速度快

1、创建字典

字典由键（key）和对应值（value）成对组成。字典也被称作关联数组或哈希表。基本语法如下：

dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}

dict1 = {‘name’: ‘景浩’, ‘sex’: ‘男’, ‘age’: 18}

print(dict1)

{‘name’: ‘景浩’, ‘sex’: ‘男’, ‘age’: 18}

创建空字典两种方法：
dict2 = {}
dict2 = dict()

注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中{}。
键必须独一无二，且键必须是不可变类型。但值则不必。
值可以取任何数据类型
字典是可变数据类型

设置可变类型的键，报错

python中，键相同有警告，但不会报错。 生产中严禁有相同的的键

set 和 dict 的注意点
字典的键 和 集合的值 有数据类型上的要求:
(允许的类型范围)不可变的类型: Number(int float complex bool) str tuple
(不允许的类型)可变的类型 : list set dict

哈希算法的提出目的是让数据尽量均匀的在内存当中分配,以减少哈希碰撞,提升存储分配的效率;
哈希算法一定是无序的散列,所以集合 和 字典都是无序

字典的 键有要求,值没要求
字典的值可以任意换掉,但是键不可以，键必须唯一.

键值对存储的数据,表面上有序,本质上无序
dictvar = {键1:值1, 键2:值2 , … }
python3.6版本之前,完全无序,
python3.6版本之后,存储的时候,保留了字典定义的字面顺序,在获取内存中数据时
重新按照字面顺序做了排序,所以看起来有序,实际上存储时还是无序.

2、访问字典中的值

print(d[‘key’]) 如果写了不存在的值会报错

print(d.get(‘key’)) 如果写了不存在的值，默认返回None

print(d.get(‘key’,'not find ')) 如果找不到存在的值，返回 “not find” 参数一是key，参数二是查找不存在时的默认值

print(dict1.get(‘name’))

景浩

print(dict1.items()) 将字典中的键值对以元祖方式显示，数据1是key，数据2是value

dict_items([(‘name’, ‘景浩’), (‘sex’, ‘男’), (‘age’, 18), (‘id’, 10010)])

print(d.keys()) #获取所有的key 值

print(d.values()) #获取所有的value 获取值的可迭代数据

print(dict1.keys()) 返回的是可迭代数据
dict_keys([‘name’, ‘sex’, ‘age’, ‘id’])

遍历字典键值对：

if ‘key’ in d: #判断key是否存在
print(‘key’) 不存在返回空

遍历字典的key

与 for i in d.keys:
print(i) 一样

for key in dict1.keys():
print(key)

name
sex
age
id

遍历字典的value:

for value in dict1.values():
print(value)

景浩
男
18
10010

for k,v in d.items(): #遍历字典
print(k,v)
无须转换成list 格式，保留了字典原有的特性

遍历字典键值对：
for key, value in dict1.items():
print(f’{key}={value}')

name=景浩
sex=男
age=18
id=10010

for k in dict:
print(k,dict[k])
print(k,dict.get(k)) 取值速度快，性能好

遍历字典的元素： 返回的是元组数据
for item in dict1.items():
print(item)

(‘name’, ‘景浩’)
(‘sex’, ‘男’)
(‘age’, 18)
(‘id’, 10010)

3、修改字典

d[‘key’] = value key 存在即修改，key不存在即新增
这样修改，pycharm会有警告提示

两种方法，可以解决
1.使用dict()方法创建字典，然后添加元素
2.使用update()方法来修改字典，没有就添加

还可以直接将字典直接添加到新字典中

dic.update(ww=“王文”,zl=“张磊”)
print(dic)

d.setdefault(‘key’,value) 只能新增

dict1[‘id’] = 10010
print(dict1)
{‘name’: ‘景浩’, ‘sex’: ‘男’, ‘age’: 18, ‘id’: 10010}

#2.fromkeys 使用一组键和默认值创建字典
tup = (“a”,“b”,“c”)
#fromkeys(盛放键的容器,默认值)
dic = {}.fromkeys(tup,None)
print(dic)
方便快速创建已知一组键的字典，这组键必须是不可变类型

#注意点 (字典中的三个键默认指向的是同一个列表)
dic= {}.fromkeys(tup,[])
print(dic)
dic[“a”].append(1)
print(dic)

#改造
dic = {}
dic[“top”] = []
dic[“middle”] = []
dic[“bottom”] = []
dic[“top”].append(“the boy”)
print(dic)

4、删除字典元素

d.pop(‘key’) 必须要传值，因为字典是无序的，返回的是删除那个键的值。给定键如果不在字典中,则必须设置一个default值,否则会报错

d.popitem() 随机删，一般删除最后一个键值对 返回一个键值对(key,value)形式。

del d[‘key’] 删除指定的键值对, key必须存在

d.clear() 清空字典

5、其他

print(dict.items()) 输出一个list格式（非真正意义上的list）

dict_items([(‘name’, ‘景浩’), (‘sex’, ‘男’), (‘age’, 18)])

print(list(dict.items())) 把字典的key 和 value 转成一个多维list

[(‘name’, ‘景浩’), (‘sex’, ‘男’), (‘age’, 18)]

集合

一、集合的定义

定义：由不同元素组成的集合，集合是一组无序排列 可hash值，可作为字典的key的值才能作为集合的值。

特性：集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无须纠结于集合中的单个值。

（1、不同元素组成 2、无序 3、集合中的元素必须是不可变类型 4、自动去重）

存放可变类型报错，无法hash

获取集合元素，通过遍历：不能通过索引获取集合元素

二、集合的使用

1、声明集合

jihe = {1,2,3,4,5}

或 jihe = set(‘123’) 创建空集合只能使用set(), 因为{}是创建字典的

jihe = set(‘123’)
print(jihe)
{‘2’, ‘3’, ‘1’}

（1）自动去重

注意，集合是有不同元素组成，所以即便里面的值重复了，也会去重。

jihe2 = {1, 3, 3, 4, 3, 5}
print(jihe2)

{1, 3, 4, 5}

#获取集合中的元素 不可以
#setvar[0] error

#修改集合中的元素 不可以
#setvar[2] = 111 error

三、集合常见操作方法

1、添加元素

1、添加元素 set.add() 方法

因为集合有去重功能，所以向集合内添加已有的数据时，不进行任何操作，并且一次只能添加一个元素

s1 = {1, 2, 3}
s1.add(4)
print(s1)
{1, 2, 3, 4}

添加多个元素报错

2、update()

追加的数据是序列，不能追加单一数据，否则报错。追加单一数据时，可以用列表表示

s1.update([6, 7])
print(s1)

{1, 2, 3, 4, 6, 7}

添加单一数据时，用列表表示可以

字符串分开添加到集合

2、删除集合元素。

1）set.pop() 与 set.remove()

set1 = {“s”, 1, “234”, 2}
#pop会从集合中随机删除一个数，并返回该数据
v = set1.pop()
print(set1, "v = ", v)

#remove 可以传参数删除指定的值，但是要注意，如果传的值不存在会报错。慎用，一次只能删除一个元素，删除多个报错。

s1 = {1, 2, 3}

s1.remove(4) 删除不存在的数据报错
print(s1)

s1.remove(4)
1

KeyError: 4

（2）set.discard() 只能删除单一数据，删除多个数据报错，没有返回值

与remove（）用法相同，但是如果元素不存在，不会报错。

s1.discard(4)
print(s1)

{1, 2, 3}

删除不存在的元素不报错

四、集合的运算

在python 中，集合的概念，有点类似数学之中集合的概念。可以求出交集并集等运算操作。

1、交集 set.intersection()

取两个集合共同的部分

场景：有两组学生，第一组学生，选修了语文课，第二组学生，选修了数学课。
但是其中有一些学生即选修了语文，也选修了数学，要求快速定位到这种学生。

stu_shuxue = {“陈司”, “李大”, “王二”}
stu_yuwen = {“陈司”, “王二”}
#取交集
print(stu_shuxue.intersection(stu_yuwen))
#写法2
print(stu_shuxue&stu_yuwen)

{“陈司”, “王二”}

{“陈司”, “王二”}

2、并集，set.union(）

理解：把两个结合中所有元素组合在一起，并排重后取出结果。

场景：还是刚才的两组学生，求选修了数学和语文的全部同学名单。

stu_shuxue = {“陈司”, “李大”, “王二”}
stu_yuwen = {“陈司”, “王二”}
#取并集
print(stu_shuxue.union(stu_yuwen))
#写法2
print(stu_shuxue | stu_yuwen)

{“陈司”, “李大”, “王二”}

{“陈司”, “李大”, “王二”}

3、差集 set.difference()

理解：两个集合相减，A 减 B ，A 里有 1、2、3 B里有 2、3、4 如果 A 与B 的差集，会发现A 有 1 是B里没有的。
所以A 减 B 等于 1 ，反过来 B 减 A 就等于4 ，因为4 是A 集合里没有的元素。

也就是说，发起差集的集合，会把自己有，而对方没有的元素得到。
说的直白点，我是帅，高，富。 你是 丑 ， 高，富。咱们都有高和富，我减去你就是帅。你减去我就是丑。

set1 = {“陈司”,“高”,“富”,“帅”}
set2 = {“某人”,“高”,“富”,“丑”}
#方法1
print(set1.difference(set2))
#方法2
print(set1-set2)

{“陈司”,“帅”}
{“陈司”,“帅”}

print(set2-set1)

{“某人”,“丑”}

4、交叉补集 set.symmetric_difference()

对称差集

理解。集合A 是1、2、3 集合B 是 2、3、4 交叉补集就只保留 1 和 4 。因为 1 是 A 独有的， 4 是B 独有的。
交叉补集会去掉共有的部分，只保留双方独有的部分。

场景：选修语文的有一组学生，选修数学的有一组学生。已知有的学生既选修了数学，
又同时选修了语文，求只选修了一门课程的学生。这种情况就适合交叉补集。

#学习语文的
set_yuwen = {“陈司”,“A”,“B”,“C”}
#学习数学的
set_shuxue = {“某人”,“A”,“B”,“C”}
#方法1
print(set_shuxue.symmetric_difference(set_yuwen))
#方法2
print(set_yuwen^set_shuxue)

{“陈司”,“某人”}

{“某人”,“陈司”}

两个集合各自特有的

#issubset() 判断是否是子集
set1 = {“刘德华”,“郭富城”,“张学友”,“王文”}
set2 = {“王文”}
res = set2.issubset(set1)
print(res)

#简写
res = set2 < set1
print(res)

#issuperset 判断是否是父集
set1 = {“刘德华”,“郭富城”,“张学友”,“王文”}
set2 = {“王文”}
res = set1.issuperset(set2)
print(res)

#简写
res = set1 > set2
print(res)

#isdisjoint() 检测两集合是否不相交 不相交 True 相交False
set1 = {“刘德华”,“郭富城”,“张学友”,“王文”}
set2 = {“王文”}
res = set1.isdisjoint(set2)
print(res)

判断某个数据是否存在于集合中
in: 存在返回True,不存在返回False not in与之相反
s1 = {1, 2, 3}

print(5 in s1)

False

五、冰冻集合 (额外了解)

也属于强制转换的一个类型
“”“frozenset 单纯的只能做交差并补操作,不能做添加或者删除的操作”“”
lst = [“王文”,“宋健”,“何旭彤”]
fz1 = frozenset(lst)
print(fz1, type(fz1))

#不能再冰冻集合中添加或者删除元素
#fz1.add(1)
#fz1.update(“abc”)
#fz1.discard(“王文”)

#冰冻集合只能做交差并补，返回的依然是冰冻集合
lst2 = [“王文”,“王同培”,“刘一缝”]
fz2 = frozenset(lst2)
print(fz2, type(fz2))

#交集
res = fz1 & fz2
print(res)

#可遍历冰冻集合
for i in fz2:
print(i)