代码写的越急，程序跑得越慢。
—— Roy Carlson
目录
Python 字典是另一种非常实用的数据结构，在Python 中用dict 表示，是英文dictionary 的缩写。
>>> dict
<class 'dict'>
Python 中的dict 在其它编程语言中一般用map 表示，虽然叫法不同，但基本原来是相通的。
1，Python 字典
Python 字典中的数据，以键值对(key:value)的形式存储，字典存储的是一个一一对应 的映射关系。
Python 中的字典类型，有如下特点：
- 字典中的
键是唯一的，不重复的 - 字典中的
键可以是任意一种不可变类型，比如字符串，数字，元组 - 字典中的
值可以是任意一种数据类型 - 字典中的数据可以动态的
删除/增加/修改 - Python 会在需要的时候自动的
扩容和缩容，方便开发者使用
2，声明字典
Python 中的字典使用大括号{} 表示，字典中的值以key:value 的形式存储，注意key，value 之间有个冒号:。
示例：
>>> d = {} # 一个空字典
字典中的键 可以是任意一种不可变类型，值可以是任意类型：
>>> d = {'name':'jack', 'age':18, 'flag':True}
提示：
虽然字典中的
键可以是任意的不可变类型数据，但大部分情况下，我们只会使用字符串类型
字典中的键不能是列表这样的可变类型的数据：
>>> l = [1, 2, 3]
>>> d = {l:'123'} # 出现异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
3，字典元素个数
字典中元素的个数，就是字典中键的个数，可以用len() 查看：
>>> d = {'name':'jack', 'age':18, 'flag':True}
>>> len(d)
3
4，访问字典数据
使用索引访问某个元素
我们可以用变量名[键] 的格式来访问字典中的数据，在这里，键被称为索引。
>>> d = {'name':'jack', 'age':18, 'flag':True}
>>> d['name']
'jack'
>>> d['age']
18
>>> d['scores'] # 访问一个不存在的键，会抛异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'scores'
使用for 循环遍历字典
除了使用索引 访问字典，还可以使用for 循环遍历字典：
>>> d = {'name':'jack', 'age':18, 'flag':True}
>>> for key in d: # key 是 d 的键，d[key] 是对应的值
... print('key:%s value:%s' % (key, d[key]))
...
key:name value:jack
key:age value:18
key:flag value:True
上面的方式，是通过遍历字典中的键key，再通过索引的方式访问值d[key]。
5，修改字典
字典的修改操作包括添加元素，修改元素和删除元素。
添加和修改元素
使用索引和赋值语句可以向字典中添加和修改元素：
- 当给字典中一个
已存在的键，再次赋值，就是修改元素 - 当给字典中一个
不已存在的键，去赋值，就是添加元素
示例：
>>> d = {'a':1} # 初始化一个字典
>>> d['b'] = 2 # 给一个不存在的键去赋值，会添加元素
>>> d # 字典中多了键值对 'b':2
{'a': 1, 'b': 2}
>>> d['a'] = 3 # 给一个已存在的键去赋值，会修改这个键的值
>>> d # 键'a' 的值从原来的 1，变为了 3
{'a': 3, 'b': 2}
删除元素
使用索引和del 关键字可以删除字典中的键值对：
>>> d = {'a': 3, 'b': 2}
>>> del d['a']
>>> d
{'b': 2}
6，字典包含
可以使用 in 和not in运算符，查看一个键是否存在和不存在于一个字典中：
>>> d = {'a':1, 'b':2}
>>> 'a' in d
True
>>> 'a' not in d
False
7，字典函数
可通过dir(dict) 或 dir(字典对象) 来查看Python 字典支持的方法：
>>> dir(dict)
['__class__', '__contains__',
'__delattr__', '__delitem__',
'__dir__', '__doc__', '__eq__',
'__format__', '__ge__',
'__getattribute__', '__getitem__',
'__gt__', '__hash__', '__init__',
'__init_subclass__', '__iter__',
'__le__', '__len__', '__lt__',
'__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__',
'__setattr__', '__setitem__',
'__sizeof__', '__str__',
'__subclasshook__',
'clear', 'copy', 'fromkeys', 'get',
'items', 'keys', 'pop', 'popitem',
'setdefault', 'update', 'values']
这里我们依然只关注非魔法方法，共11 个。
1.get 方法
作用：获取字典
D中的键k的值D[k]
原型：D.get(k[,d]) -> D[k]
参数 k：要获取的键
参数 d：当D中不存在k时，返回d，d可省，默认为None
返回值：如果k存在，返回D[k]，否则返回d
示例：
>>> d = {'a':1}
>>> d.get('a') # d['a'] 存在
1
>>> b = d.get('b') # d['b'] 不存在，返回 None
>>> print(b) # b 为 None
None
>>> b = d.get('b', 5) # d['b'] 不存在，返回 5
>>> print(b) # b 为 5
5
2.update 方法
作用：使用
E和F来更新字典D中的元素
原型：D.update([E, ]**F) -> None
参数：E为字典或者其它可迭代类型
返回值：总是返回None
示例：
>>> d1 = {'a':1, 'c':3}
>>> d2 = {'a':5, 'b':7}
>>> d1.update(d2) # 对于 d2 中的所有的键k，执行 d1[k] = d2[k]
>>> d1
{'a': 5, 'c': 3, 'b': 7}
>>> d1.update(a=8, d=6) # 也可以是这种形式的参数
>>> d1
{'a': 8, 'c': 3, 'b': 7, 'd': 6}
3.fromkeys 方法
作用：创建一个新的字典，该字典以序列
iterable中的元素作为键，每个键的值都是value
原型：dict.fromkeys(iterable, value=None, /)
参数 iterable：可以是任意的可迭代类型
参数 value：新字典中的每个键的值都是value，可省，默认为None
返回值：一个新的字典
示例：
>>> dict.fromkeys({'a':1, 'c':3}) # 参数是字典类型
{'a': None, 'c': None} # 一个新的字典，每个键的值都是 None
>>> dict.fromkeys({'a':1, 'c':3}, 5)
{'a': 5, 'c': 5} # 每个键的值都是 5
>>> dict.fromkeys(['a', 'b']) # 参数是列表类型
{'a': None, 'b': None}
4.items 方法
作用：将字典
D转换成一个可遍历的列表，列表中的元素由D中的键值对组成
原型：D.items() -> dict_items
参数：无
返回值：一个dict_items类型的可遍历的列表
示例：
>>> d = {'a':1, 'c':3}
>>> items = d.items()
>>> items # 将d 中的 key:vale 转成了 (key, value)
dict_items([('a', 1), ('c', 3)])
>>> type(items) # 类型为 dict_items
<class 'dict_items'>
将
dict_items类型理解为一个可遍历的列表即可，列表中的元素是元组类型
该方法常用于遍历字典：
>>> d = {'a':1, 'c':3}
>>> for k, v in d.items():
... print(k, v)
...
a 1
c 3
5.keys 方法
作用：返回字典
D中所有的键
原型：D.keys() -> dict_keys
参数：无
返回值：一个dict_keys类型的可遍历的列表
示例：
>>> d = {'a':1, 'c':3}
>>> keys = d.keys()
>>> keys # 提取了 d 中所有的键
dict_keys(['a', 'c'])
>>> type(keys)
<class 'dict_keys'>
将
dict_keys类型理解为一个可遍历的列表即可
6.values 方法
作用：返回字典
D中所有的值
原型：D.values() -> dict_values
参数：无
返回值：一个dict_values类型的可遍历的列表
示例：
>>> d = {'a':1, 'c':3}
>>> vs = d.values()
>>> vs # 提取了 d 中所有的键
dict_values([1, 3])
>>> type(vs)
<class 'dict_values'>
将
dict_values类型理解为一个可遍历的列表即可
7.pop 方法
作用：删除字典
D中的键k，并返回D[k]
原型：D.pop(k[,d]) -> v
参数 k：要删除的键
参数 d：若D[k]存在，返回D[k]，若D[k]不存在，则返回d。参数d可省
返回值：
D[k]存在时，返回D[k]
D[k]不存在，参数d存在时，返回d
D[k]不存在且参数d不存在，抛出KeyError异常
示例，当要pop 的键存在时：
>>> d = {'a': 1, 'c': 3}
>>> d.pop('c') # d['c'] 存在
3 # 返回 d['c']
>>> d # 键 'c' 被删除，只剩 'a'
{'a': 1}
示例，当要pop 的键存在时：
>>> d.pop('c') # 键 'c' 不存在，抛出异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'c'
>>>
>>> d.pop('c', 5) # 键'c' 不存在，但有第二个参数
5 # 返回第 2 个参数
8.popitem 方法
作用：删除并返回字典
D中的最后一个键值对，顺序是先进后出
原型：D.popitem() -> (k, v)
参数：无
返回值：一个元组类型，D为空时，抛出异常
关于popitem 的顺序：
- 如果声明字典时，已有元素，按照
从左到右的书写顺序，左为前，右为后 - 当动态向字典中增加元素时，先加入的为前，后加入的为后
示例，声明字典时，已有元素：
>>> d = {'c':3, 'a':1, 'b':2}
>>> d # 顺序为 c,a,b
{'c': 3, 'a': 1, 'b': 2}
>>> d.popitem() # pop 出 'b'
('b', 2)
>>> d # 还剩 c, a
{'c': 3, 'a': 1}
>>> d.popitem() # pop 出 'a'
('a', 1)
>>> d # 还剩 'c'
{'c': 3}
向字典中添加元素z和x：
>>> d['z'] = 6 # 增加 'z'
>>> d
{'c': 3, 'z': 6}
>>> d['x'] = 8 # 再增加 'x'
>>> d # 现在的顺序为 c,z,x
{'c': 3, 'z': 6, 'x': 8}
再次执行popitem：
>>> d.popitem() # pop 出 x
('x', 8)
>>> d # 还剩 c,z
{'c': 3, 'z': 6}
>>> d.popitem() # pop 出 z
('z', 6)
>>> d # 还剩 c
{'c': 3}
>>> d.popitem() # pop 出 c
('c', 3)
>>> d # 字典为空
{}
字典为空时，执行popitem，抛出异常：
>>> d.popitem() # 抛出异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
9.setdefault 方法
作用：设置字典
D中键k的值当
D[k]存在时：不做任何事情，只返回D[k]
当D[k]不存在时：执行D[k] = d，并返回d原型：D.setdefault(k[,d]) -> value
参数 k：要设置的键
参数 d：要设置的值，可省，默认为None
返回值：返回D[k]
示例，当要设置的键存在时：
>>> d = {'a':1}
>>> d.setdefault('a') # d['a'] 存在，只返回d['a']
1
>>> d # d 不改变
{'a': 1}
>>> d.setdefault('a', 5) # d['a'] 存在，只返回d['a']
1
>>> d # d 不改变
{'a': 1}
当要设置的键不存在时：
>>> i = d.setdefault('b') # d['b'] 不存在，没有第 2 个参数
>>> d # 执行 d['b'] = None
{'a': 1, 'b': None} # 执行后的结果
>>> print(i) # 返回值为 None
None
>>> d.setdefault('x', 6) # d['x'] 不存在，有第 2 个参数，执行d['x'] = 6
6 # 返回 d['x']
>>> d # d 现在的值
{'a': 1, 'b': None, 'x': 6}
10.clear 方法
作用：清空字典
D
原型：D.clear() -> None
参数：无
返回值：总是返回None
示例：
>>> d = {'a': 1, 'b': None, 'x': 6}
>>> d.clear()
>>> d # d 为空
{}
11.copy 方法
作用：浅拷贝字典
D
原型：D.copy() -> dict
参数：无
返回值：字典D的副本
示例：
>>> d = {'a': 1, 'b': None, 'x': 6}
>>> d1 = d.copy()
>>> d1
{'a': 1, 'b': None, 'x': 6}
（完。）
推荐阅读：
Python 简明教程 --- 7，Python 字符串
Python 简明教程 --- 8，Python 字符串函数
Python 简明教程 --- 9，Python 编码
Python 简明教程 ---10，Python 列表
Python 简明教程 ---11，Python 元组
