2021-5-7 字典和集合 课程总结

2021-5-7 字典和集合 课程总结

什么是字典(dict)

• 字典是容器型数据类型(序列)，将{}作为容器标志，里面多个元素用逗号隔开（每个元素必须是键值对）{键1：值1，键2：值2，键3：值3，…}
• 字典是可变的（支持增删改）；字典无序（不支持下标操作）
• 键：不可变的数据才可以作为字典的键（数字、字符串、元组）；键是唯一的
• 值：值才是字典真正想要保存的数据，键只是的作用就像列表中的下标用来对值进行区分和说明的。值可以是任何类型的数据。

1. 空字典

dict1 = {}
print(dict1,type(dict1),len(dict1))

2. 字典无序

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

3. 键是不可变的

print({10:20,'abc':100,(1,2):300})

4. 键是唯一的

print({10:20,'abc':30,10:40,'abc':50})      # 保留后面的{10: 40, 'abc': 50}

1. 查 - 获取值

dog = {'name':'财财','breed':'土狗','gender':'母狗','age':2}

1. 查单个:

a. 字典[键] - 获取字典中指定键对应的值，键不存在会报错

print(dog['name'])
print(dog['age'])

b. 字典.get(键) - 获取字典中指定对应的值，键不存在不会报错返回None

print(dog.get('breed'))

# print(dog['height'])        # KeyError: 'height'
print(dog.get('height'))        # None

c. 字典.get(键,默认值) - 获取字典中指定对应的值,键不存在b不会报错返回指定默认值

print(dog.get('height',0))      # 0

2. 遍历

"""
for 变量 in 字典:
    循环体

注意：变量取到的是字典的键
"""
dog = {'name':'财财','breed':'土狗','gender':'母狗','age':2}
for x in dog:
    print(x,dog[x])

students = [
    {'name': '程明明', 'age': 27, 'score': 89, 'tel': '18860901744', 'gender': '男'},
    {'name': '梅迁', 'age': 26, 'score': 93, 'tel': '13567193428', 'gender': '男'},
    {'name': '张三', 'age': 18, 'score': 43, 'tel': '15367423810', 'gender': '女'},
    {'name': '李四', 'age': 34, 'score': 65, 'tel': '13799413758', 'gender': '不明'},
    {'name': '王麻子', 'age': 23, 'score': 76, 'tel': '15533753219', 'gender': '男'},
    {'name': '李冰冰', 'age': 17, 'score': 99, 'tel': '17742589773', 'gender': '女'}
]
# count1= [x for x in students if x['age'] < 18]
# print(count1)

练习：通过列表推导式获取字典所有的值

stu = {'name': '程明明', 'age': 27, 'score': 89, 'tel': '18860901744', 'gender': '男'}
# ['程明明', 27, 89, '18860901744', '男']
new_stu = [stu[x] for x in stu]
print(new_stu)

2. 增、改

字典[key] = 值 - 当键不存在的时候添加键值对，当键存在的时候修改指定键对应的值

dog = {'name':'财财','breed':'土狗','gender':'母狗','age':2}
print(dog)

添加

dog['weight'] = 10
print(dog)

修改

dog['name'] = '旺财'
print(dog)

3. 删

1) del 字典[键] - 删除字典中指定键对应的键值对

dog = {'name':'财财','breed':'土狗','gender':'母狗','age':2}
del dog['breed']
print(dog)

# del dog['height']   # KeyError: 'height'

2) 字典.pop(键) - 取出字典中指定键对应的值

dog = {'name':'财财','breed':'土狗','gender':'母狗','age':2}
del_val = dog.pop('gender')
print(dog,del_val)

4. 运算符

字典不支持比较运算（比较大小）和数学运算

print([1,2,3,4,5] > [10,20])      # False,比较第一队不相等的元素的大小
# print({'a':10} > {'a':20})        # TypeError: '>' not supported between instances of 'dict' and 'dict'
# print({'a':20} + {'b': 30})       # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

5. in 和 not in

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

键 not in字典

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
print('咖啡' in cat)          # False 看的是键
print('name' in cat)         # True

6. 相关函数： len dict

print(len(cat))     # 长度 3

# dict(数据)  - 将指定数据转换成字典
#               数据的要求：a.数据本身是一个序列
#                         b.序列中的元素必须是有且只有两个元素的小序列
#                         c.小序列中的元素必须是不可变的数据
seq = [(10,20),'ab']
result = dict(seq)
print(result)           # {10: 20, 'a': 'b'}

result = dict((x,x*2)for x in range(3))
print(result)           # {0: 0, 1: 2, 2: 4}

# 字典转列表
cat = {'name':'咖啡','color':'白色','breed':'折耳'}
print(list(cat))        # ['name', 'color', 'breed']

7. 字典相关方法

1. 字典.clear()

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
cat.clear()
print(cat)

2. 字典.copy()

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
cat2 = cat.copy()
print(cat2,id(cat),id(cat2))

3. keys 、 values 、items

• 字典.keys() - 获取字典所有的键，返回值是序列
• 字典.values() - 获取字典所有的值，返回值是序列
• 字典.items() - 将字典转换成元素是元组的序列（一个键值对对应一个元组）

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
print(cat.values())         # dict_values(['咖啡', '白色', '折耳'])
print(cat.keys())           # dict_keys(['name', 'color', 'breed'])
print(cat.items())          # dict_items([('name', '咖啡'), ('color', '白色'), ('breed', '折耳')])

for x, y in cat.items():
    print(x,y)

4. 字典.setdefault(键，值) - 添加键值对（键存在的时候不会修改）

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
cat.setdefault('weight',10)
print(cat)                  # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 'weight': 10}

cat.setdefault('color','黑色')
print(cat)                  # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 'weight': 10}

5. 字典.updote(序列) - 将序列中的元素添加到字典中（序列必须是可以转换成字典的序列）批量添加

字典1.update(字典2) - 将将字典2中所有的键值对添加到字典1中

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
cat.update([(10,20),'ab'])
print(cat)              # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 10: 20, 'a': 'b'}

cat = {'name':'咖啡','color':'白色','breed':'折耳'}
cat.update({'a':10,'b':20,'color':'黑色'})
print(cat)              # {'name': '咖啡', 'color': '黑色', 'breed': '折耳', 'a': 10, 'b': 20}

什么是集合(set)

• 集合是容器型数据类型(序列)，将{}作为容器标志，里面多个元素用逗号隔开：{元素1，元素2，元素3，…}
• 集合是可变的(支持增删改)；无序的(不支持下标操作)
• 集合的元素：必须的不可变的数据；唯一的

1. 空集合

set1 = set()
# set() <class 'set'> 0
print(set1,type(set1),len(set1))

2. 集合无序

print({1,2,3} == {3,2,1})     # True

3. 集合的元素是不可变的数据

print({10,'abc',(2,3)})
# print({10,'abc',[2,3]})     # 报错

4. 集合元素是唯一的

print({10,20,30,10,10,20})      # {10, 20, 30}

集合的增删改查

1. 查 - 只有遍历

nums = {10,78,67,35,70,89}
for x in nums:
    print(x)

2. 增 -

集合.add(元素) - 在集合中添加指定元素
集合.update(序列) - 将序列中所有的元素都添加到集合中

nums.add(100)
print(nums)         # {35, 67, 100, 70, 10, 78, 89}

nums.update('abc')
print(nums)         # {35, 67, 100, 70, 'c', 10, 'a', 78, 'b', 89}

nums.update({'name':'张三','age':18})
print(nums)         # {35, 67, 100, 70, 'c', 10, 'a', 78, 'name', 'age', 'b', 89}

3. 删

集合.remove(元素) - 删除指定元素 - 元素不存在的时候会报错
集合.discard(元素) - 删除指定元素 - 元素不存在的时候就不管它

nums = {35, 67, 100, 70, 10, 78, 89}
nums.remove(100)
print(nums)         # {67, 35, 70, 10, 78, 89}

nums.discard(35)
print(nums)         # {67, 70, 10, 78, 89}

数学集合运算

数学集合运算：&（交集）、|（并集）、-（差集）、^（对称差集）、><（判断是否是真子集）、>=<=（判断是否是子集）

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7}

1. 集合1 & 集合2 - 交集（获取两个集合公共部分）

print(set1 & set2)      # {4, 5, 6}

2. 集合1 | 集合2 - 并集(将两个集合合并产生一个新的集合)

print(set1 | set2)      # {1, 2, 3, 4, 5, 6, 7}

3. 集合1 - 集合2 - 差集（获取集合1中除了包含在集合2以外的元素）

print(set1 - set2)      # {1, 2, 3}
print(set2 - set1)      # {7}

4. 集合1 ^ 集合2 - 对称差集（获取集合1和集合2合并去掉公共部分）

print(set1 ^ set2)      # {1, 2, 3, 7}

5. 子集

什么是真子集 - 集合1 包含 集合2中的元素并多一些元素
集合1 > 集合2 - 判断集合2 是否是集合1的真子集。 空集也算
集合1 >= 集合2 - 判断集合2 是否是集合1的子集 子集包含本身

print({10,20,30,40} > {1,2}) # False
print({10,20,30,40} > {10,20}) # True
print({10,20} > {10,20})  # False
print({10,20} >= {10,20})  # True