共计 4316 个字符，预计需要花费 11 分钟才能阅读完成。
字典 (dict, dictionary 的简写) 是 Python 中另一个非常重要的内置数据类型，是 Python 中映射类型 (Mapping Type)，它把“键”(key) 映射到“值”(value)，通过 key 可以快速找到 value，它是一种“键值对”(key-value)数据结构。
“键”，可以是任意不可变的类型对象 (可以做 hash，即具有hash() 和eq()方法的对象），通常是字符串和数字，同一个字典中键是唯一的。但不能是 list，因为 list 可以通过索引、切片、append()和 extend()方法改变其值。
“值”，可以是任何类型的数据。
Python 字典 (dict) 的创建
字典可以通过 dict() 或一对花括号创建一个空字典: d = {}。花括号内可以放用逗号 , 隔开的多个键值对，键值对用冒号 : 隔开:
In [1]: d1 = {}
In [2]: d2 = dict()
In [3]: d1 == d2
Out[3]: True
In [4]: d3 = {'a': 1, 'b': 2, 'c': 3}
In [5]: d3
Out[5]: {'a': 1, 'b': 2, 'c': 3}
In [6]: d4 = {'a': 1, 'a':2, 'a':3}
In [7]: d4
Out[7]: {'a': 3}
上面最后一个例子 d4 的初始化中，键都是'a'，所以得到的字典只有一个键，它的值是最后一次赋值3.
dict()创建字典对象
dict()无参数时生成空字典，也可以通过传入参数进行初始化。传入参数有两种形式：
一种是，序列型数据 list 或 tuple，它每个元素必须又含有两个子元素，以满足 key-value 对；
一种是，name=value 形式的参数。
见下面的例子：
In [21]: d1
Out[21]: {'a': 1, 'b': 2, 'c': 3}
In [22]: d2 = dict(a=1, b=2, c=3)
In [23]: d2
Out[23]: {'a': 1, 'b': 2, 'c': 3}
字典推导式（Dict Comprehension)
类似列表推导式，我们可以通过一个 for 循环表达式来创建一个字典：
In [10]: dd = {x: x*x for x in range(5)}
In [11]: dd
Out[11]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
list 不能做字典的 key，但是可以做 value：
In [12]: l1 = [1,2,3]
In [13]: d = {'a': l1}
In [14]: d = {l1: 'a'}
----------------------
TypeError Traceback (most recent call last)
<ipython-input-14-bcd280c2bff6> in <module>
----> 1 d = {l1: 'a'}
TypeError: unhashable type: 'list'
Python 字典 (dict) 的访问
(1)通过键访问其值
列表可以通过其索引访问元素，字典就是通过键访问对应的值，形式类似列表那样用方括号，只不过用“键”替代了“索引”。方法是字典对象名称加方括号括起来的键名，比如：mydict['a']。如果某个键不在字典对象中，通过方括号访问就会报错：
In [26]: myd = dict(a=1, b=2, c=3)
In [27]: myd
Out[27]: {'a': 1, 'b': 2, 'c': 3}
In [28]: myd['a']
Out[28]: 1
In [29]: myd['e']
------------------
KeyError Traceback (most recent call last)
<ipython-input-29-86b81ed4647a> in <module>
----> 1 myd['e']
KeyError: 'e'
(2)通过 get(key)方法访问其值
给 get()传入键作为参数，就可以得到 value，如果 key 不存在则返回 None。
In [30]: myd.get('a')
Out[30]: 1
In [31]: print(myd.get('e'))
None
Python 字典 (dict) 的更改
详见下面的示例代码：
In [32]: myd = dict(a=1, b=2, c=3)
In [33]: myd['a'] = 9 # 改变某个键的值
In [34]: myd
Out[34]: {'a': 9, 'b': 2, 'c': 3}
In [35]: myd['e'] = 8 # 增加新的键值对
In [36]: myd
Out[36]: {'a': 9, 'b': 2, 'c': 3, 'e': 8}
In [37]: del myd['e'] # 删除某个键及其值
In [38]: myd
Out[38]: {'a': 9, 'b': 2, 'c': 3}
In [39]: myd.pop('c') # 删除某个键及其值并得到其值
Out[39]: 3
In [40]: myd
Out[40]: {'a': 9, 'b': 2}
Python 字典 (dict) 相关的内置函数
Python 内置了一些函数可以用于操作字典，它们是：
- len()
返回字典的长度，是键的个数，也是值的个数，也是键值对的个数。空字典的长度是 0
In [41]: len({'a':1, 'b':2})
Out[41]: 2
In [42]: len({})
Out[42]: 0
- any()和 all()
类似于对列表、tuple 的操作，不过这两个函数检验的是字典的键(key)。
any(): 只要字典有一个键为 True 则返回 True；
all(): 只有字典的所有键都为 True 才返回 True；
In [45]: any({'': 1, 0:'abcd', False: 333})
Out[45]: False
In [46]: all({'': 1, 0:'abcd', False: 333})
Out[46]: False
In [47]: all({'a': 1, 0: 'abcd', False: 333})
Out[47]: False
In [48]: any({'a': 1, 0: 'abcd', False: 333})
Out[48]: True
In [49]: any({})
Out[49]: False
In [50]: all({})
Out[50]: True
不过，空字典有意思，它没有键却认为是所有键都为 True，all({})返回 True。
- sorted()
跟操作列表、tuple 的效果一样，它把字典的所有 key 当做一个列表（或元组）进行排序
In [51]: sorted({'a': 1, 'c': 3, 'b': 4})
Out[51]: ['a', 'b', 'c']
in 运算符
跟列表，元组一样，in用来检验一个 key 是不是在字典中：
In [56]: 'a' in {'a': 1, 'c': 3, 'b': 4}
Out[56]: True
In [57]: '3' in {'a': 1, 'c': 3, 'b': 4}
Out[57]: False
In [58]: '3' not in {'a': 1, 'c': 3, 'b': 4}
Out[58]: True
遍历字典：
In [59]: for key in {'a': 1, 'c': 3, 'b': 4}:
...: print(key)
...:
a
c
b
Python 字典 (dict) 的内置方法：
（1）keys()
返回键 (key) 的 view 对象（类型是：dict_keys）。这个 view 对象可以动态查看字典内部的对象，当字典改变后，这个 view 对象也会反应变化。
Python 2 时，返回的是 list，现在是 dict_keys。
In [76]: myd = dict(a=1, b=2, c=3)
In [77]: kk = myd.keys()
In [78]: type(kk)
Out[78]: dict_keys
In [79]: for k in kk:
...: print(k)
...:
a
b
c
In [80]: myd['e'] = 9 # 修改了字典
In [81]: for k in kk: # 并没有重新获取 kk，但是 kk 已经反应了变化，多了 e
...: print(k)
...:
a
b
c
e
（2）values()
返回值 (value) 的 view 对象，dict_values。
（3）items()
返回键值对 (key-value) 的 view 对象：dict_items
In [82]: vv = myd.values()
In [83]: vv
Out[83]: dict_values([1, 2, 3, 9])
In [84]: ii = myd.items()
In [85]: ii
Out[85]: dict_items([('a', 1), ('b', 2), ('c', 3), ('e', 9)])
（4）get(key)
获取 key 对应的 value，上面已经讲到。
（5）clear()
清空一个字典
In [86]: myd.get('a')
Out[86]: 1
In [87]: myd.get('x', 0)
Out[87]: 0
In [88]: myd.clear()
In [89]: myd
Out[89]: {}
（6）copy()
在 Python 中，把列表，字典对象赋值给变量时，都是“浅拷贝”，即，变量指向了对象，原来的对象改变了，这个变量的值也会跟着变。而 cop()函数是“深拷贝”，重新创造一个新对象赋值给变量，原来的对象的改变不影响新对象。
In [94]: d1 = {'a':1}
In [95]: d2 = d1 # 浅拷贝
In [96]: d3 = d1.copy() # 深拷贝
In [97]: d1['a'] = 2 # 改变原来的字典
In [98]: d2
Out[98]: {'a': 2} # 浅拷贝的 d2 也跟着改变
In [99]: d3
Out[99]: {'a': 1} # 深拷贝的 d3 还是原来的值
（7）pop(key)
删除 key 并返回它的值，上面已经讲到。
（8）popitem()
返回一对键值：
In [105]: myd = dict(a=1, b=2, c=3)
In [106]: myd.popitem()
Out[106]: ('c', 3)
In [107]: myd.popitem()
Out[107]: ('b', 2)
（9）fromkeys()
通过一个序列来初始化字典：
In [109]: d = {}
In [110]: d.fromkeys([1,2,3])
Out[110]: {1: None, 2: None, 3: None}
In [111]: d.fromkeys([1,2,3], 0)
Out[111]: {1: 0, 2: 0, 3: 0}
（10）update()
用一个字典来更新另一字典：
In [113]: d = d.fromkeys([1,2,3], 0)
In [114]: d
Out[114]: {1: 0, 2: 0, 3: 0}
In [115]: d.update({1:10, 2:20})
In [116]: d
Out[116]: {1: 10, 2: 20, 3: 0}
总结
字典是 Python 中很重要的一个数据结构，也是 Python 内置的数据类型。今后的编程中会经常用到它，所以要熟练掌握它的各种操作。
