day8-字典和集合_字典可不可以关系运算

day8-字典和集合

1字典相关操作和方法

1.字典不支持加法、乘法和 >、<、>=、<=

2.字典支持 ==、!=

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})
1

3.in 和 not in

键 in 字典 ---- 判断字典中是否存在指定的键

d1 = {'a': 10, 'b': 20, 'c': 30}
print(30 in d1)  # False
print('b' in d1)  # True
1
2
3

4.类型转换dict

"""
dict(数据)  -   将数据转换成字典
数据的要求：1）数据本身是一个序列
		  2）序列中的元素必须是长度为2的小序列
		  3）小序列的第一个元素必须是不可变的数据
"""
1
2
3
4
5
6

result = dict([(1,2), 'ab',['b', 100]])   
print(result)    # {1: 2, 'a': 'b', 'b': 100}
1
2

注意：将字典转换成列表或者元组的时候，将字典的键作为列表、元组中的元素

d1 = {'a': 10, 'b': 20, 'c': 30}
print(list(d1))  # ['a', 'b', 'c']
print(tuple(d1))  # ('a', 'b', 'c')
1
2
3

5.相关方法

​ 1）字典.clear() - 清空字典

d1 = {'a': 10, 'b': 20, 'c': 30}
print(d1.clear())  # {}
1
2

​ 2）字典.copy() - 克隆

stu1 = {'name': '小明', 'gender':'男', 'age': 19}
stu2 = stu1.copy()
print(stu2)  # {'name': '小明', 'gender':'男', 'age': 19}
stu2['name'] = '张三'    # 将克隆后的stu2的键name对应的值修改为张三
print(stu2)  # {'name': '张三', 'gender':'男', 'age': 19}
print(stu1)  # {'name': '小明', 'gender':'男', 'age': 19} 因为克隆所以stu1里面的不变
1
2
3
4
5
6

​ 3）字典.get() - 通过建获取值

​ 4）字典.items() - 将字典中的元素转换成元组，返回一个新的序列

# {键1:值1, 键2:值2}  -->  [(键1, 值1), (键2, 值2)]
stu1 = {'name': '小明', 'gender':'男', 'age': 19}
result = stu1.items()
print(type(result))   # <class 'dict_items'>
print(result)  # dict_items([('name', '小明'), ('gender', '男'), ('age', 19)])
1
2
3
4
5

# 字典推导式：{键值对 for 变量 in 序列}、{键值对 for 变量 in 序列 if 条件}
# 练习:使用列表推导式，将一个字典的值全部乘以10
d2 = {'a': 2, 'b': 34, 'c': 21}
# {'a': 20, 'b': 340, 'c': 210}
# 方法1
d3 = {key: value*10 for key, value in d2.items()}
print(d3)  # # {'a': 20, 'b': 340, 'c': 210}
# 方法2
d3 = dict([key, value*10] for key, value in d2.items())
print(d3)   # # {'a': 20, 'b': 340, 'c': 210}
# 方法3
d3 = {x:d2[x]*10 for x in d2}
print(d3)  # # {'a': 20, 'b': 340, 'c': 210}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 使用字典推导式交换字典的键和值
d2 = {'a': 2, 'b': 34, 'c': 21}
# {2: 'a', 34: 'b', 21: 'c'}
d3 = {value: key for key, value in d2.items()}
1
2
3
4

​ 5）字典.key() - 获取字典所有的键，返回一个新的序列

d2 = {'a': 2, 'b': 34, 'c': 21}
print(d2.key())  # dict_keys(['a', 'b', 'c'])
1
2

​ 6）字典.values() - 获取字典所有的值，返回一个新的序列

d2 = {'a': 2, 'b': 34, 'c': 21}
print(d2.values())  # dict_values([2, 34, 21])
1
2

​ 7）字典.setdefault(键, 值) - 在字典中添加一个键值对，如果字典中已存在这个键值对时，不会执行修改操作，没有时则添加

# 字典[键] = 值  -  改建存在时修改该键对应的值，不存在则添加
d2 = {'a': 2, 'b': 34, 'c': 21}
d2.setdefault('c', 23)
print(d2)   # {'a': 2, 'b': 34, 'c': 21}
1
2
3
4

# 练习
goods_list = [
    {'name': '泡面', 'price': 4, 'discount': 0.9, 'count': 100},
    {'name': '火腿肠', 'price': 2, 'count': 120},
    {'name': '矿泉水', 'price': 1, 'count': 500},
    {'name': '面包', 'price': 5, 'count': 120, 'discount': 0.75}
]
for good in goods_list:
    good.setdefault('discount', 1)
print(goods_list)
1
2
3
4
5
6
7
8
9
10

​ 8）字典.update(序列) - 将序列中的元素全部添加到字典中

​ 序列 - 是字典或者是能转换成字典的序列

d1 = {'a': 10, 'b': 20}
d2 = {'name': '小明', 'age': 19, 'a': 100}
d1.update(d2)
print(d1)  # {'a': 100, 'b': 20，'name': '小明', 'age': 19}
d1.update(['mn',(1, 2)])
print(d1)  # # {'a': 100, 'b': 20，'name': '小明', 'age': 19, 'm': 'n', 1: 2}
1
2
3
4
5
6

2集合

1.什么是集合（set）

​ 集合是容器型数据类型（序列），将{}作为容器的标志，里面多个元素用逗号隔开：{元素1，元素2，元素3，…}

​ 集合作为容器的特点：集合是可变的（支持增删改），无序的（不支持下标操作）

​ 集合对元素的要求：1）必须是不可变的数据；2）必须是唯一的

# 1)空集合
s1 = set()
print(s1, type(s1))  # {} <class 'set'>
print(len(s1))  # 0
1
2
3
4

#2) 集合元素必须是不可变的数据
set2 = {1, 'a', (1, 3)}
print(set2)   # {1, (1, 3), 'a'} (因为集合是无序的，不用管顺序)
1
2
3

# 3)集合无序
print({1, 2, 3} == {2, 3, 1})  # True(因为集合是无序的)
1
2

# 4)元素是唯一的
set3 = {1, 2, 3, 1, 2, 4, 3, 5}
print(set3) # {1, 2, 3, 4, 5}
1
2
3

2.集合的增删改

# 1)查 -  只能遍历
hobby = {'玩游戏', '看电影', '打篮球', '爬山', '做饭'}
for x in hobby:
    print(x, end=' ')  # 玩游戏 做饭 爬山 看电影 打篮球
1
2
3
4

# 2)增
# 集合.add(元素)
# 集合.update(序列)
hobby = {'玩游戏', '看电影', '打篮球', '爬山', '做饭'}
hobby.add('游泳')
print(hobby)  # '玩游戏', '做饭', '游泳', '爬山', '看电影', '打篮球'}
hobby.update(('兵乓球','羽毛球'))
print(hobby)  # {'玩游戏', '兵乓球', '做饭', '羽毛球', '游泳', '爬山', '看电影', '打篮球'}
1
2
3
4
5
6
7
8

# 3)删
# 集合.remove(元素) - 如果元素不存在会报错
# 集合.discard(元素) - 如果元素不存在，不会报错，不会异常捕获
hobby.remove('做饭')
print(hobby)  # {'兵乓球', '游泳', '爬山', '看电影', '羽毛球', '玩游戏', '打篮球'}
hobby.discard('玩游戏') # # {'游泳', '看电影', '打篮球', '羽毛球', '爬山', '兵乓球'}
1
2
3
4
5
6

3数学集合运算

1.python中的集合支持数学集合运算

​ 1）并集 : |

​ 集合1 | 集合2 ------- 将两个集合合并成一个集合

s1 = {1, 2, 3, 4, 5, 6}
s2 = {4, 5, 6, 7, 8}
print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7, 8}
1
2
3

​ 2）交集：&

​ 集合1 & 集合2 ------- 获取两个集合的公共部分，产生一个新的集合

s1 = {1, 2, 3, 4, 5, 6}
s2 = {4, 5, 6, 7, 8}
print(s1 & s2)  # {4, 5, 6}
1
2
3

​ 3）差集：-

​ 集合1 - 集合2 -------- 获取集合1中去掉包含集合2中的元素，剩下的元素

s1 = {1, 2, 3, 4, 5, 6}
s2 = {4, 5, 6, 7, 8}
print(s1 - s2) # {1, 2, 3}
print(s2 - s1) # {7, 8}
1
2
3
4

​ 4）对称差集：^

​ 集合1 ^ 集合2 -------- 将两个集合合并去掉公共部分，获取剩下的部分

s1 = {1, 2, 3, 4, 5, 6}
s2 = {4, 5, 6, 7, 8}
print(s1 ^ s2)  # {1, 2, 3, 7, 8}
1
2
3

​ 5）判断子集关系

​ 子集：>=、<=

​ 真子集：>、<

​ 集合1 > 集合2 ------- 判断集合2是否是集合1的真子集

​ 集合1 < 集合2 ------ 判断集合1是否是集合2的真子集

s3 = {10, 20, 30}
# 真子集:{10},{20},{30},{10,20},{10,30},{20,30},空集
# 子集:{10},{20},{30},{10,20},{10,30},{20,30},空集,{10, 20, 30}
print({100, 200, 300} > {1, 2,3})  # False
print({100, 200, 300} > {100})  # True
1
2
3
4
5

# 练习:
# 用三个集合表示三门学科的选课学生姓名(一个学生可以同时选多门课)
course1 = {'小花', '小明', '小张', '小强', '小华', '小陈'}
course2 = {'小张', '小王', '小明', '小碧', '小芳', '小陈'}
course3 = {'小花', '小明', '小张', '小苏', '小王', '小陈'}
print('----------------1-------------------')
# 1. 求选课学生总共有多少人
course_num = course1 | course2 | course3
print('选课学生总共有:', len(course_num))
print('-----------------------2--------------')
# 2. 求只选了第一个学科的人的数量和对应的名字
course_c1 = course1 - course2 - course3
print('只选了第一个学科的人的数量:', len(course_c1))
print('只选了第一个学科的人:', course_c1)
print('-----------------------5--------------')
# 5. 求选了三门学生的学生的数量和对应的名字
course_3 = course1 & course2 & course3
print('选了三门学科的人的数量:', len(course_3))
print('选了三门学科的人的姓名:', course_3)

print('-----------------------3--------------')
# 3. 求只选了一门学科的学生的数量和对应的名字
# 方法1
course_1 = (course1 - course2 - course3) | (course2 - course1 -course3) | (course3 - course1 -course2)
print('只选了一个学科的人的数量:', len(course_1))
print('只选了一个学科的人的姓名:', course_1)
# 方法2
course_1 = course1 ^ course2 ^ course3 - course_3
print('只选了一个学科的人的数量:', len(course_1))
print('只选了一个学科的人的姓名:', course_1)
print('-----------------------4--------------')
# 4. 求只选了两门学科的学生的数量和对应的名字
# 方法1
course_2 = (course1 & course2 - course3) | (course2 & course3 - course1) | (course1 & course3 - course2)
print('只选了两个学科的人的数量:', len(course_2))
print('只选了两个学科的人的姓名:', course_2)
# 方法2
course_2 = course_num - course_3 - course_1
print('只选了两个学科的人的数量:', len(course_2))
print('只选了两个学科的人的姓名:', course_2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40