1. 字典

主要属性：

• 通过键读取：字典又叫关联数组（associative array）或散列表（hash）。
• 任意对象的无序集合
• 可变长、异构、任意嵌套
• 属于可变映射类型
• 对象引用表（散列表）

常见字典常量和操作:

操作	解释
D = {}	空字典
D = {'name': 'Bob', 'age':40}	两项目字典
D = {'cto':{'name': 'Bob', 'age':40}}	嵌套
D = dict(name = 'Bob', age = 40)	关键字
D = dict([('name', 'Bob), ('age', '40')])	键值对
D = dict(zip(keyslist, valueslist))	zipped键值对
D = dict.fromkeys(['a', 'b'])	键列表
D['name']	以键进行索引运算
D['cto']['age']
'age' in D	成员关系：键存在测试
D.keys()	方法：键
D.values()	值
D.items()	键+值
D.copy()	副本
D.clear()	删除所有项
D.update(D2)	合并
D.get(key, default?)	通过键获取，如果不存在则返回None或者用户定义的默认值
D.pop(key, default?)	通过键删除，…
D.setdefault(key, default?)	通过键获取，if absent set default(or None)
D.popitem()	删除/返回任意键值对
len(D)	长度（存储的元素的数目）
D[key] = 42	新增/修改键
del D[key]	根据键删除条目
list(D.keys())	字典视图（python 3.X）
D1.keys() & D2.keys()
D.viewkeys(), D.viewvalues()	字典视图（python 2.7）
D = {x: x*2 for x in range(10)}	字典解析式

2. 实际应用中的字典

2.1 字典基本操作

创建字典并通过键来存储、访问其中的某项：

D = {'spam': 2, 'ham': 1, 'eggs': 3}    # 创建字典
D['spam']                               # 通过键取值

2

len(D)                          # 字典中项的数量

3

'ham' in D                      # 键成员关系

True

2.2 原处修改字典

D = {'eggs': 3, 'ham': 1, 'spam': 2}

D['ham'] = ['grill', 'bake', 'fry']        # 改变项
D

{'eggs': 3, 'ham': ['grill', 'bake', 'fry'], 'spam': 2}

del D['eggs']                              # 删除项
D

{'ham': ['grill', 'bake', 'fry'], 'spam': 2}

D['brunch'] = 'Bacon'                      # 添加新项
D

{'ham': ['grill', 'bake', 'fry'], 'spam': 2, 'brunch': 'Bacon'}

2.3 其他字典方法

字典 values 和 items 方法分别返回字典的致列表和（key, value）对元组。

D = {'spam':2, 'ham':1, 'eggs':3}
list(D.values())

[2, 1, 3]

list(D.items())

[('spam', 2), ('ham', 1), ('eggs', 3)]

键不存在时通过 get 方法能够返回默认值（None 或者用户定义的默认值）。

D.get('spam')                # 键存在

2

print(D.get('toast'))        # 键不存在

None

D.get('toast', 88)

88

字典的 update 方法类似于合并，但是和从左到右的顺序无关。它把一个字典的键和值合并到另一个字典中，盲目地覆盖相同键的值。

D = {'eggs':3, 'ham':1, 'spam':2}
D2 = {'toast':4, 'muffin':5}
D.update(D2)
D

{'eggs': 3, 'ham': 1, 'muffin': 5, 'spam': 2, 'toast': 4}

字典 pop 方法能够从字典中删除一个键并返回它的值，类似于列表的 pop 方法。

D.pop('muffin')

5

2.4 字典用法注意事项

• 序列运算无效：字典是映射机制，不是序列
• 对新索引赋值会添加项
• 键不一定总是字符串：任何不可变对象都可以作为键，元组偶尔允许合并键值时也可以用作字典键，类实例对象也可以用作键

字典用于稀疏数据结构
例如多维数组中只有少数位置上有存储的值，数组中只有两个位置有值，其他位置都为空。

Matrix = {}
Matrix[(2, 3, 4)] = 88
Matrix[(7, 8, 9)] = 99
Matrix

{(2, 3, 4): 88, (7, 8, 9): 99}

避免 missing-key 错误

1. 在 if 语句中预先对键进行测试
2. 使用 try 语句明确地捕获并修复这一异常
3. 使用 get 方法为不存在的键提供一个默认值

if (2, 3, 6) in Matrix:
    print(Matrix[(2, 3, 6)])
else:
    print(0)

0

try:
    print(Matrix[(2, 3, 6)])
except KeyError:
    print(0)

0

Matrix.get((2, 3, 4), 0)

88

2.5 创建字典的其他方法

1. 事先写出所有字典：{'name': 'mel', 'age': 45}
2. 一次动态建立字典的一个字段：

   D = {}
   D['name'] = 'mel'
   D['age'] = 45

3. 关键字形式：dict(name = 'mel', age = 45)
4. 键值元组形式：dict([('name', 'mel'), ('age', 45)])

如果所有键的值都相同，可以简单地传入一个键列表，以及所有键的初始值（默认为空）：
dict.fromkeys(['a', 'b'], 0)

dict.fromkeys(['a', 'b'], 0)

{'a': 0, 'b': 0}

3. 其他字典用法

3.1 字典解析

字典解析隐式地运行一个循环，根据每次迭代收集表达式的键值结果，并使用它们来填充一个新的字典，一个循环变量允许解析在过程中使用的循环迭代值。

{k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}

{'a': 1, 'b': 2, 'c': 3}

{x: x ** 2 for x in [1, 2, 3, 4]}

{1: 1, 2: 4, 3: 9, 4: 16}

{c: c * 4 for c in 'SPAM'}

{'S': 'SSSS', 'P': 'PPPP', 'A': 'AAAA', 'M': 'MMMM'}

3.2 字典视图

字典的 keys、values 和 items 都返回视图对象，视图对象是可迭代的，这意味着对象每次产生一个结果项，而不是在内存中立即产生结果列表。

D = dict(a=1, b=2, c=3)
D

{'a': 1, 'b': 2, 'c': 3}

D.keys()                # 创建一个视图对象，而不是一个列表

dict_keys(['a', 'b', 'c'])

list(D.keys())          # 如果需要，强制建立一个列表

['a', 'b', 'c']

D.values()

dict_values([1, 2, 3])

D.items()

dict_items([('a', 1), ('b', 2), ('c', 3)])

Python 3 的字典自己仍然拥有迭代器，返回连续键。

for key in D:           # 迭代中不需调用 keys()
    print(key)

a
b
c

3.3 字典视图与集合

keys 方法所返回的视图对象类似于集合，并且支持交集和并集等常见的集合操作；values 视图不是这样的，因为它们不是唯一的；但 items 结果是的。

K = {'a': 1, 'b': 2, 'c': 3}.keys()
K | {'x':4}

{'a', 'b', 'c', 'x'}

K & {'b'}             # 键和集合交

{'b'}

K & {'b': 1}          # 键和字典交

{'b'}

如果字典项视图是可散列（只包含不可变对象）的话，它们是类似于集合的。

D = {'a': 2}
D.items() | K         # 视图和视图并

{('a', 2), 'a', 'b', 'c'}

3.4 排序字典键

由于 keys 不会返回一个列表，要在 Python 中通过排序建来浏览一个字典的编码模式，需要手动转换为一个列表，或者在一个键视图或字典自身上使用 sorted 方法。

D = {'a':1, 'b':2, 'c':3}
Ks = list(D.keys())               # 转换为列表之后排序
for k in Ks:
    print(k, D[k])

a 1
b 2
c 3

Ks = D.keys()               # 或者在键上使用 sorted
for k in sorted(Ks):        # sorted 接受任意可迭代对象
    print(k, D[k])

a 1
b 2
c 3

可以直接排序字典，字典迭代器返回的是 keys

for k in sorted(D):
    print(k, D[k])

a 1
b 2
c 3