Python自学9（字典和集合）

" 在这边的世界里是藏不住眼泪的哦，想哭的时候谁都会忍不住的… "

1、字典

1.1、字典概念

1. 字典
2. 字典是一种用来存放若干键值对的数据类型
3. 键值对
4. 键值对就是两个对象、其中一个是用来做定位的数据、叫做键（Key）
5. 另一个是要存放的数据、叫做值（Value）
6. 在字典中、键值对作为一个整体被存放、我们可以通过键来快速获取到对应的值

# 在 Python 中字典用花括号来表示
# 键值对以 键:值 的方式写入花括号中、有多个键值对时用逗号分隔
dict1 = {
     '010': 'beijing', '021': 'shanghai'}

# dict1是一个字典、包含二对键值对
'010': 'beijing'
'021': 'shanghai'
# 使用时、我们可以通过 '010' 快速查询到其对应的值是 'beijing'

1.2、字典特点

1. Python 字典中的键是有要求的、需要是不可变的类型
2. 如元组、字符串、数字
3. 而字典中的值可以是任意类型
4. 字典本身是可变的、我们可以向其中添加、删除、修改键值对
5. 因为字典不是序列、更不是有序的
6. 所有它没有列表那样的索引、也不能保证每个键值对的存放次序

1.3、创建字典

1.3.1、创建空的字典

# 语法
字典 = {
     }

empty_dict = {
     }
print(empty_dict)
# output:{}

1.3.2、创建包含键值对的字典

# 语法
字典 = {
     键1:值1, 键2:值2, ..., 键N:值N}

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes)
# output:{'beijing': '010', 'shanghai': '021'}

1.4、字典键值对的添加

1. 使用这种方式时、若字典中没有这个键、则会创建这个键值对
2. 若字典中原本已有这个键、则是修改键所对应的值

# 语法
字典[键] = 值

codes = {
     'beijing': '010', 'shanghai': '021'}
codes['wuhan'] = '022'
print(codes)
# output:{'beijing': '010', 'shanghai': '021', 'wuhan': '022'}

1.5、键值对的获取

1.5.1、通过键获取值

# 语法
值 = 字典[键]

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes['beijing'])
# output:010

# 注意若键不存在则将抛出 KeyError 异常
codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes['b'])
# output:KeyError（键）: 'b'

1.5.2、通过键获取值（ get 方法）

1. 如果通过键获取值时不希望 KeyError 异常抛出、可以使用 get 方法
2. 若键不存在、则直接返回 None
3. 也可以给 get 方法传递第二个参数作为默认值
4. 使得键不存在时直接返回默认值

# 语法
值 = 字典.get(键)

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.get('beijing'))
print(codes.get('wuhan'))
print(codes.get('bwuhan','hhh'))
# output:010
#        None
#        hhh

1.5.3、判断字典中是否包含某个键

# 语法
布尔值 = 键 in 字典

codes = {
     'beijing': '010', 'shanghai': '021'}
print('beijing' in codes)
print('wuhan' in codes)
# output:True
#        False

1.5.4、获取所有键

# 语法
键的列表 = 字典.keys()

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.keys())
# output:dict_keys(['beijing', 'shanghai'])

# 获取到的所有键是以迭代器的形式存在
# 用 list() 函数将迭代器转换为列表
codes = {
     'beijing': '010', 'shanghai': '021'}
print(list(codes.keys()))
# output:['beijing', 'shanghai']

1.5.5、获取所有值

# 语法
值的列表 = 字典.values()

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.values())
# output:dict_values(['010', '021'])

# 获取到的所有值是以迭代器的形式存在
# 用 list() 函数将迭代器转换为列表
codes = {
     'beijing': '010', 'shanghai': '021'}
print(list(codes.values()))
# output:['010', '021']

1.5.6、获取所有键值对的列表

# 语法
值的列表 = 字典.items()

codes = {
     'beijing': '010', 'shanghai': '021'}
print((codes.items()))
# output:dict_items([('beijing', '010'), ('shanghai', '021')])

# 获取到的所有键值对是以迭代器的形式存在
# 用 list() 函数将迭代器转换为列表
codes = {
     'beijing': '010', 'shanghai': '021'}
print((list(codes.items())))
# output:[('beijing', '010'), ('shanghai', '021')]

1.6、字典键值对的删除

1.6.1、通过键删除键值对（pop方法）

• 可以使用 pop 方法删除一个键值对、并将值返回

# 语法
值 = 字典.pop(键)

codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.pop('beijing'))
# output:010

# 如果 pop 一个不存在的键、则会抛出 KeyError 异常
codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.pop('b'))
# output:KeyError: 'b'

# 如果你不希望异常抛出、可以传递 pop 方法的第二个参数作为默认值
# 默认值仅在键不存在时生效、此时方法将直接返回这个默认值、且跳过删除操作
codes = {
     'beijing': '010', 'shanghai': '021'}
print(codes.pop('b',123))
# output:123

1.6.2、通过键删除键值对（del方法）

# 语法
del 字典[键]

codes = {
     'beijing': '010', 'shanghai': '021'}
del codes['beijing']
print(codes)
# output:{'shanghai': '021'}

1.6.3、随机删除一个键值对

1. 使用 popitem 随机删除一个键值对、并返回这个键值对的二元组
2. 二元组的第一个元素是键、第二个元素是值

# 语法
键值二元组 = 字典.popitem()

codes = {
     'beijing': '010', 'shanghai': '021'}
a = codes.popitem()
print(codes)
print(a)
# output:{'beijing': '010'}
#        ('shanghai', '021')

1.6.4、清空所有键值对

# 语法
键值二元组 = 字典.clear()

codes = {
     'beijing': '010', 'shanghai': '021'}
codes.clear()
print(codes)
# output:{}

1.7、字典中键值对修改

1.7.1、修改键对应的值

# 语法
字典[键] = 值

codes = {
     'beijing': '010', 'shanghai': '021'}
codes['beijing'] = '000'
print(codes)
# output:{'beijing': '000', 'shanghai': '021'}

# 如果键不存在、则创建键值对
codes = {
     'beijing': '010', 'shanghai': '021'}
codes['wuhan'] = '000'
print(codes)
# output:{'beijing': '010', 'shanghai': '021', 'wuhan': '000'}

1.7.2、用字典批量更新键值对

# 语法
字典.update(另一字典)

codes = {
     'beijing': '010', 'shanghai': '021'}
codes.update({
     'beijing':'000','tianjing':'888'})
print(codes)
# output:{'beijing': '000', 'shanghai': '021', 'tianjing': '888'}

1.8、什么时候用字典

1. 字典的显著优势是可以通过键快速地查询数据
2. 字典中的元素以键值对的形式存在、使用时通过键来获取和修改值
3. 由于字典内部的特殊实现、字典通过键获取值的效率非常高
4. 如果我们希望将批量的数据存放起来
5. 并且在需要时能以很高的执行效率来获取其中某个指定的数据
6. 这时就可以使用字典
7. 如果我们想在程序中暂时维护一个映射关系
8. 这时也可以使用字典
9. 因为字典本质上就是一个映射关系

# 我们可以将城市名和对应的区号保存在字典中
# 这样就可以通过城市名快速地查询到其区号、而不需要进行遍历
area_codes = {
     
    '北京': '010',
    '上海': '021',
    '天津': '022',
    '重庆': '023',
    '沈阳': '024',
    '南京': '025',
    '武汉': '027',
    '成都': '028',
}
print(area_codes['北京'])
print((area_codes.get('上海')))
# output:010
#        021

2、集合

1. 集合是一个用于存放批量元素的数据类型
2. 它不是有序的、其中的元素没有顺序关系
3. 集合中的元素没有重复、重复的元素将被自动剔除最终只留下一个
4. 集合也是用花括号来表示
5. 不同于字典的是、花括号中放的是一个个数据、而不是键值对
6. 集合是可变的、我们可以向其中添加、删除、修改元素

2.1、创建集合

2.1.1、创建空集合

# 语法
# 注意创建空集合不能直接使用 {}、那样是表示空字典
# 而是使用 set()、这才表示空集合
集合 = set()

empty_set = set()
print(empty_set)
# output:set()

2.1.2、创建包含元素的集合

# 语法
集合 = {
     元素1, 元素2, 元素N}

set1 = {
     1,2,3}
print(set1)
# output:{1, 2, 3}

2.2、集合元素的添加

2.2.1、向集合中添加一个元素

# 语法
集合.add(元素)

set1 = {
     1,2,3}
set1.add(4)
print(set1)
# output:{1, 2, 3, 4}

# 向集合中添加重复元素时、会被去重处理
set1 = {
     1,2,3}
set1.add(2)
print(set1)
# output:{1, 2, 3}

2.2.2、从另一集合中批量添加元素

# 语法
集合.update(另一集合)

set1 = {
     1,2,3}
set2 = {
     3,4,5,6}
set1.update(set2)
print(set1)
# output:{1, 2, 3, 4, 5, 6}

2.3、集合元素的获取

1. 集合不能像列表那样通过索引来获取元素
2. 也不能像字典那样通过键来获取值
3. 集合没法直接获取到某个指定的元素
4. 想要获取元素、只能通过遍历的方式
5. 虽然集合不能直接获取到元素
6. 但是我们依然可以用 in 关键字来判断元素是否存在于集合中

2.3.1、查看元素是否存在于集合中

# 语法
布尔值 = 元素 in 集合

set1 = {
     1,2,3}
print(4 in set1)
# output:False

2.4、集合元素的删除

2.4.1、随机删除一个元素，并返回这个元素

# 语法
元素 = 集合.pop()

set1 = {
     1,2,3}
print(set1.pop())
# output:1
# 默认返回第一个元素

2.4.2、删除一个指定的元素

# 语法
集合.remove(元素)

set1 = {
     1,2,3}
set1.remove(2)
print(set1)
# output:{1, 3}

# 如果要删除的元素不存在、则抛出 KeyError 异常
set1 = {
     1,2,3}
set1.remove(4)
# output:KeyError: 4

2.4.3、删除一个指定的元素（不抛出 KeyError 异常）

# 语法
集合.discard(元素)

set1 = {
     1,2,3}
set1.discard(4)
print(set1)
# output:{1, 2, 3}

2.4.4、清空所有元素

# 语法
集合.clear()

set1 = {
     1,2,3}
set1.clear()
print(set1)
# output:set()

# 列表、字典清空元素也是使用此方法
# 元组没有这个方法是因为元组不可变

2.5、集合的运算

2.5.1、求交集

%1
# 语法
# 可以通过 intersection 方法求多个集合的交集
交集 = 集合1.intersection(集合2, 集合3, 集合N)

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,6,7}
set4 = set1.intersection(set2,set3)
print(set4)
# output:{1}

%2
# 语法
# 也可以直接使用与运算符 & 来代替、完全等效
交集 = 集合1 & 集合2 & 集合N

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,6,7}
set4 = set1 & set2 & set3
print(set4)
# output:{1}

2.5.2、求并集

%1
# 语法
# 可以通过 union 方法求多个集合的交集
并集 = 集合1.union(集合2, 集合3, 集合N)

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,6,7}
set4 = set1.union(set3,set2)
print(set4)
# output:{1, 2, 3, 4, 5, 6, 7}

%2
# 语法
# 也可以直接使用或运算符 | 来代替、完全等效
并集 = 集合1 | 集合2 | 集合N

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,6,7}
set4 = set1 | set3 | set2
print(set4)
# output:{1, 2, 3, 4, 5, 6,}

2.5.3、求差集

%1
# 语法
# 可以通过 difference 方法求多个集合的交集
差集 = 集合1.difference(集合2, 集合3, 集合N)

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,2,7}
set4 = set1.difference(set3,set2)
print(set4)
# output:{3}

%2
# 语法
# 也可以直接使用运算符  -  来代替、完全等效
差集 = 集合1 - 集合2 - 集合N

set1 = {
     1,2,3}
set2 = {
     1,4,5}
set3 = {
     1,2,7}
set4 = set1 - set3 - set2
print(set4)
# output:{3}

2.5.4、判断是否为子集

# 语法
布尔值 = 集合1.issubset(集合2)

set1 = {
     1,2,3}
set2 = {
     1,2}
print(set2.issubset(set1))
# output:True

2.5.5、判断是否为超集

# 语法
布尔值 = 集合1.issuperset(集合2)

set1 = {
     1,2,3}
set2 = {
     1,2,3}
print(set1.issuperset(set2))
# output:True

2.6、什么时候用集合

1. 集合非常重要的一个特性是元素无重复
2. 每个元素都是唯一的、重复的元素将被自动剔除（去重）
3. 所以如果我们需要存放一系列的数据、并且不希望其中出现重复、那么就可以使用集合
4. 另外如果想计算两个数据集的交集、并集、差集
5. 使用集合来承载数据再合适不过了、集合自带的集合运算能轻松解决这些问题

2.7、获取字典和集合中的元素数量

# 利用 len() 函数
set1 = {
     1,2,3}
dict1 = {
     'tianjing':'010','wuhan':'023'}
print(len(set1))
print(len(dict1))
# output:3
#        2

3、总结

3.1、字典

1. 字典是一种用来存放若干键值对的数据类型、可通过键来快速查找值
2. 字典的键需要是不可变的类型、如数字、字符串和元组
3. 字典的值可以是任意类型
4. 字典本身是可变的，所以可向其中添加、修改、删除键值对

3.2、集合

1. 集合是一个用于存放批量元素的序列
2. 它不是有序的、且元素不会有重复
3. 集合也是可变的、我们可以向其中添加、删除、修改元素