完整讲解 · 3 段教学·配 7 道练习题·预计 70 分钟
本页是本章的通读版，可直接读完全部讲解。想动手写代码、跑判分，去 闯关模式。
上一篇文章出现了个明显的知识点错误，不过感谢有个网友的提出，及时进行了修改。也希望各位多多包涵。
注：(2019年09月01日15:28:00) 在修改文章的时候，发现自己两年前写的像屎一样, 忍不住还在群里吐槽一番。
群友：@水哥 水哥是在写 Python 教程吗
水哥：在修改
水哥：两年前写完了基础教程的
水哥：最近在全部修改一边
水哥：发现之前写的就是 屎
上一章节，我们学习了列表（List） 和 元组（tuple） 来表示有序集合。
而我们在讲列表（list）的时候，我们用了列表（list） 来存储用户的姓名。
name = ['一点水', '两点水', '三点水', '四点水', '五点水']那么如果我们为了方便联系这些童鞋，要把电话号码也添加进去，该怎么做呢？
用 list 可以这样子解决：
name = [['一点水', '131456780001'], ['两点水', '131456780002'], ['三点水', '131456780003'], ['四点水', '131456780004'], ['五点水', '131456780005']]但是这样很不方便，我们把电话号码记录下来，就是为了有什么事能及时联系上这些童鞋。
如果用列表来存储这些，列表越长，我们查找起来耗时就越长。
这时候就可以用 dict （字典）来表示了，Python 内置了 字典（dict），dict 全称 dictionary，如果学过 Java ，字典就相当于 JAVA 中的 map，使用键-值（key-value）存储，具有极快的查找速度。
name = {'一点水': '131456780001', '两点水': '131456780002', '三点水': '131456780003', '四点水': '131456780004', '五点水': '131456780005'}字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
dict = {key1 : value1, key2 : value2 }注意：键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的。
更准确地说，字典的键必须可哈希。包含列表的元组虽然自身不可变，也不能作为字典键；不能只根据「可变／不可变」判断。
创建 dict（字典）实例：
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
dict2={'abc':1234,1234:'abc'}我们知道了怎么创建列表了，回归到一开始提出到的问题，为什么使用字典能让我们很快的找出某个童鞋的电话呢？
name = {'一点水': '131456780001', '两点水': '131456780002', '三点水': '131456780003', '四点水': '131456780004', '五点水': '131456780005'}
print(name['两点水'])输出的结果：
131456780002可以看到，如果你知道某个人的名字，也就是 key 值， 就能很快的查找到他对应的电话号码，也就是 Value 。
这里需要注意的一点是：如果字典中没有这个键，是会报错的。
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
print(dict1)
# 新增一个键值对
dict1['jack']='444444'
print(dict1)
# 修改键值对
dict1['liangdianshui']='555555'
print(dict1)输出的结果：
{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333'}
{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}
{'liangdianshui': '555555', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}通过 del 可以删除 dict （字典）中的某个元素，也能删除 dict （字典）
通过调用 clear() 方法可以清除字典中的所有元素
#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
print(dict1)
# 通过 key 值，删除对应的元素
del dict1['twowater']
print(dict1)
# 删除字典中的所有元素
dict1.clear()
print(dict1)
# 删除字典
del dict1输出的结果：
{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333'}
{'liangdianshui': '111111', '两点水': '333333'}
{}(1) dict （字典）是不允许一个键创建两次的，但是在创建 dict （字典）的时候如果出现了一个键值赋予了两次，会以最后一次赋予的值为准
例如：
#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333','twowater':'444444'}
print(dict1)
print(dict1['twowater'])输出的结果：
{'liangdianshui': '111111', 'twowater': '444444', '两点水': '333333'}
444444(2) dict （字典）键必须不可变，可是键可以用数字，字符串或元组充当，但是就是不能使用列表
例如：
#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,123:'222222' ,(123,'tom'):'333333','twowater':'444444'}
print(dict1)输出结果：
{'liangdianshui': '111111', 123: '222222', (123, 'tom'): '333333', 'twowater': '444444'}(3) dict 内部存放的顺序和 key 放入的顺序是没有任何关系
和 list 比较，dict 有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢
需要占用大量的内存，内存浪费多
而list相反：
查找和插入的时间随着元素的增加而增加
占用空间小，浪费内存很少
| 方法和函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数 |
| str(dict) | 输出字典可打印的字符串表示 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
| dict.clear() | 删除字典内所有元素 |
| dict.copy() | 返回一个字典的浅复制 |
| dict.values() | 以列表返回字典中的所有值 |
| popitem() | 随机返回并删除字典中的一对键和值 |
| dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
各位童鞋，前面咱们讲了 dict 的增、删、改、查。这里再补一个 Python 3.9 之后才出现的好东西—— dict 合并运算符 | 和 |= 。
为什么要专门讲它啊？
我们先来看一个需求，假设水哥手上有两份联系人字典，需要把它们合并成一份：
old_contacts = {'一点水': '131456780001', '两点水': '131456780002'}
new_contacts = {'三点水': '131456780003', '两点水': '131456780099'}注意上面，水哥 这个 key 在两份里都有，我们希望以「新的」为准。
在 Python 3.9 之前，常见的写法是这样：
old_contacts = {'一点水': '131456780001', '两点水': '131456780002'}
new_contacts = {'三点水': '131456780003', '两点水': '131456780099'}
merged = {**old_contacts, **new_contacts}
print(merged)输出的结果：
{'一点水': '131456780001', '两点水': '131456780099', '三点水': '131456780003'}这种 ** 解包写法没毛病，但是不够直观。 Python 3.9 之后，可以直接用 | ：
old_contacts = {'一点水': '131456780001', '两点水': '131456780002'}
new_contacts = {'三点水': '131456780003', '两点水': '131456780099'}
merged = old_contacts | new_contacts
print(merged)输出的结果：
{'一点水': '131456780001', '两点水': '131456780099', '三点水': '131456780003'}是不是发现，跟 set 的并集 | 长得一模一样？没错，作者就是这个意思——「把两个 dict 合并起来」。
如果你不想生成新字典，而是直接「在原字典上」合并新内容，那就用 |= ：
old_contacts = {'一点水': '131456780001', '两点水': '131456780002'}
new_contacts = {'三点水': '131456780003', '两点水': '131456780099'}
old_contacts |= new_contacts
print(old_contacts)输出的结果：
{'一点水': '131456780001', '两点水': '131456780099', '三点水': '131456780003'}注意，| 是「右边覆盖左边」，跟 {**a, **b} 的逻辑一致。各位用的时候要留意这一点，别把哪边是新的、哪边是旧的搞反了。
最后，再啰嗦一个之前没有强调的点：从 Python 3.7 开始，dict 已经「保留插入顺序」了。也就是说，前面讲的「dict 内部存放的顺序和 key 放入的顺序是没有任何关系」这条结论，在现代 Python 里其实已经不成立了。看看这个例子：
d = {}
d['c'] = 3
d['a'] = 1
d['b'] = 2
for key in d:
print(key)输出的结果：
c
a
b是不是发现，遍历的顺序就是当初插入的顺序？这是 Python 3.7+ 的语言级保证（之前 3.6 已经是 CPython 的实现细节，但没写进规范）。所以现在大多数情况下，你不再需要专门去 import collections.OrderedDict 了，普通的 dict 就够用。
我们已经记下 Python 学了 15 分钟、读书用了 10 分钟。如果又学了 5 分钟 Python，是新增一个相同的键，还是修改原来的值呢？
totals = {'Python': 15, '读书': 10}
totals['Python'] = totals['Python'] + 5
print(totals)
print(totals.get('数学', 0))输出：
{'Python': 20, '读书': 10}
0同一个字典中，一个键只能对应一个值。赋值前先取出原来的 15，加上 5，再存回去，所以 Python 的累计时间变成了 20。get('数学', 0) 则表示：如果没有这个科目，就返回我们给出的默认值 0，不会因此增加一个新键。
各位自己试一下：把右边改成直接赋值 5，结果有什么不同？再给字典加上一个新科目，观察已有记录是否还在。学到循环以后，我们再来处理很多条学习记录。
请创建一个字典 phone_book，存这三对联系人：
'Alice' → '13800001111''Bob' → '13800002222''Carol' → '13800003333'然后 print(phone_book)。
输出应该是：
{'Alice': '13800001111', 'Bob': '13800002222', 'Carol': '13800003333'}dict 的写法：{'key1': 'value1', 'key2': 'value2'}
完整代码：
phone_book = {'Alice': '13800001111', 'Bob': '13800002222', 'Carol': '13800003333'}
print(phone_book)已经给你定义了：
scores = {'语文': 90, '数学': 85, '英语': 78}请用 print 打印 数学 这一科的分数（用 scores['数学']）。
输出应该是：
85用 dict[key] 的形式取值
完整代码：
scores = {'语文': 90, '数学': 85, '英语': 78}
print(scores['数学'])已经给你定义了：
scores = {'语文': 90, '数学': 85}请：
'英语': 78'数学' 的分数改成 92print(scores)输出应该是：
{'语文': 90, '数学': 92, '英语': 78}新增和修改都是 dict[key] = value——key 不存在就新增，存在就覆盖
完整代码：
scores = {'语文': 90, '数学': 85}
scores['英语'] = 78
scores['数学'] = 92
print(scores)已经给你定义了：
old = {'a': 1, 'b': 2}
new = {'b': 99, 'c': 3}请用 | 把它们合并成 merged（注意：右边覆盖左边，所以 'b' 应该取 99），然后 print(merged)。
输出应该是：
{'a': 1, 'b': 99, 'c': 3}Python 3.9+ 才有 | 合并写法
右边的 'b': 99 会覆盖左边的 'b': 2
完整代码：
old = {'a': 1, 'b': 2}
new = {'b': 99, 'c': 3}
merged = old | new
print(merged)python 的 set 和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
set 和 dict 类似，但是 set 不存储 value 值的。
创建一个 set，需要提供一个 list 作为输入集合
set1=set([123,456,789])
print(set1)输出结果：
{456, 123, 789}传入的参数 [123,456,789] 是一个 list，而显示的 {456, 123, 789} 只是告诉你这个 set 内部有 456, 123, 789 这 3 个元素，显示的顺序跟你参数中的 list 里的元素的顺序是不一致的，这也说明了 set 是无序的。
还有一点，我们观察到输出的结果是在大括号中的，经过之前的学习，可以知道，tuple (元组) 使用小括号，list (列表) 使用方括号, dict (字典) 使用的是大括号，dict 也是无序的，只不过 dict 保存的是 key-value 键值对值，而 set 可以理解为只保存 key 值。
注意这里的版本区别：Python 3.7 起，普通字典保证保持键的插入顺序；集合仍不保证插入顺序。字典保持顺序不等于自动按键排序。
回忆一下，在 dict （字典） 中创建时，有重复的 key ，会被后面的 key-value 值覆盖的，而 重复元素在 set 中自动被过滤的。
set1=set([123,456,789,123,123])
print(set1)输出的结果：
{456, 123, 789}通过 add(key) 方法可以添加元素到 set 中，可以重复添加，但不会有效果
set1=set([123,456,789])
print(set1)
set1.add(100)
print(set1)
set1.add(100)
print(set1)输出结果：
{456, 123, 789}
{456, 123, 100, 789}
{456, 123, 100, 789}通过 remove(key) 方法可以删除 set 中的元素
set1=set([123,456,789])
print(set1)
set1.remove(456)
print(set1)输出的结果：
{456, 123, 789}
{123, 789}因为 set 是一个无序不重复元素集，因此，两个 set 可以做数学意义上的 union(并集), intersection(交集), difference(差集) 等操作。
用文氏图理解一下三种集合运算：
例子：
set1=set('hello')
set2=set(['p','y','y','h','o','n'])
print(set1)
print(set2)
# 交集 (求两个 set 集合中相同的元素)
set3=set1 & set2
print('\n交集 set3:')
print(set3)
# 并集 （合并两个 set 集合的元素并去除重复的值）
set4=set1 | set2
print('\n并集 set4:')
print(set4)
# 差集
set5=set1 - set2
set6=set2 - set1
print('\n差集 set5:')
print(set5)
print('\n差集 set6:')
print( set6)
# 去除海量列表里重复元素，用 hash 来解决也行，只不过感觉在性能上不是很高，用 set 解决还是很不错的
list1 = [111,222,333,444,111,222,333,444,555,666]
set7=set(list1)
print('\n去除列表里重复元素 set7:')
print(set7)
运行的结果：
{'h', 'l', 'e', 'o'}
{'h', 'n', 'o', 'y', 'p'}
交集 set3:
{'h', 'o'}
并集 set4:
{'h', 'p', 'n', 'e', 'o', 'y', 'l'}
差集 set5:
{'l', 'e'}
差集 set6:
{'p', 'y', 'n'}
去除列表里重复元素 set7:
{555, 333, 111, 666, 444, 222}各位童鞋，前面讲的几条 set 用法在 Python 各个版本都能用。这里再补三个现代写法里比较常见的小知识，让你写代码的时候更顺手。
我们之前学列表的时候，用过列表推导式，比如 [x * x for x in range(5)] 。其实 set 也有自己的「集合推导式」，写法几乎一样，只是把外面的方括号换成大括号：
# 取 1 到 10 中所有偶数的平方
squares = {x * x for x in range(1, 11) if x % 2 == 0}
print(squares)输出的结果：
{64, 4, 36, 100, 16}是不是发现，最后的结果自动就是「无序、不重复」的，根本不需要再手动调用 set() 转一道。
举个更贴近业务的例子，假设水哥想从一堆订单里，提取出「不重复的下单用户」：
orders = [
{'user': '一点水', 'amount': 100},
{'user': '两点水', 'amount': 200},
{'user': '一点水', 'amount': 50},
{'user': '三点水', 'amount': 300},
]
users = {order['user'] for order in orders}
print(users)输出的结果（顺序可能不同）：
{'两点水', '一点水', '三点水'}一行就搞定，比先建空 set 再 add 干净多了。
普通的 set 是可变的，可以 add 、 remove 。可是某些时候，我们想要一个「不能再改」的集合，比如把它当作 dict 的 key，或者放进另一个 set 里。
这时候就要用 frozenset ：
fs = frozenset([1, 2, 3])
print(fs)
# 可以做集合运算
print(fs & frozenset([2, 3, 4]))
# 可以当作 dict 的 key
config = {frozenset(['admin', 'editor']): '后台权限'}
print(config[frozenset(['editor', 'admin'])])输出的结果：
frozenset({1, 2, 3})
frozenset({2, 3})
后台权限注意最后一段，frozenset(['admin', 'editor']) 和 frozenset(['editor', 'admin']) 是相等的——因为 set 本来就无序——所以两次查找命中的是同一个 key。
最后这点不是新语法，但是很重要。我们做「成员判断」的时候，比如 x in collection ：
collection 是 list ，复杂度是 O(n)，元素越多越慢collection 是 set （或 dict），复杂度接近 O(1) ，跟元素数量基本无关所以，如果你的代码里有大量「这个东西在不在那一堆里」的判断，把那一堆从 list 转成 set，往往能让性能瞬间起飞：
# 有 10 万个用户名，要判断某个名字在不在
names_list = [f'user_{i}' for i in range(100000)]
names_set = set(names_list)
# 这两种写法结果一样，但是后者快得多
print('user_99999' in names_list)
print('user_99999' in names_set)输出的结果：
True
True是不是发现，set 的价值不光是「去重」，更重要的是「快查」。各位以后在写代码的时候，遇到「频繁的 in 判断」，就可以考虑把那个集合换成 set。
已经给你定义了：
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]请：
nums 转成 set，去重sorted() 把 set 排序成 list，赋给 unique（这样输出顺序稳定）print(unique)输出应该是：
[1, 2, 3, 4, 5, 6, 9]set(nums) 自动去重——重复值只保留一个
sorted(set) 把 set 转成有序的 list
完整代码：
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
unique = sorted(set(nums))
print(unique)已经给你定义了：
tags = {'python', 'web'}请：
add 添加 'ai'add 添加一次 'python'（已存在，不会有变化）print(sorted(tags)) 把元素排序后打印（这样输出稳定）输出应该是：
['ai', 'python', 'web']tags.add(x) 添加元素，重复添加同一个值无效
set 是无序的，print 顺序不固定——所以题目让你 sorted 再 print
完整代码：
tags = {'python', 'web'}
tags.add('ai')
tags.add('python')
print(sorted(tags))已经给你定义了：
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}请用 & 求 a 和 b 的交集（两边都有的元素），再用 sorted() 转成排序后的 list，赋给 common，然后 print(common)。
输出应该是：
[3, 4, 5]a & b 求两个 set 的交集
sorted() 转成有序 list 让输出稳定
完整代码：
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
common = sorted(a & b)
print(common)读完了？动手练一遍才算真会。
去闯关模式练习 →