字典是内置类型中唯一的映射（Mapping）结构，基于哈希表存储键值对数据。

值可以是任意类型的数据，但主键必须是可哈希的类型。常见的可变类型，如列表、集合等都不能作为主键使用。即便是元组等不可变类型，也不能引用可变类型元素，即元组中不能含有可变类型的元素。

>>> import collections
>>> issubclass(list, collections.Hashable)
False
>>> issubclass(int, collections.Hashable)
True

>>> hash((1, 2, 3))
2528502973977326415
>>> hash((1, 2, [1, 2]))        # 包含可变类型
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

哈希计算通过调用 __hash__ 方法返回整数值，用来快速比较内容是否相同。某些类型虽然有该方法，但实际无法执行，故不能作为主键使用。另外，主键对象的哈希值必须恒定不变，否则无法查找键值，甚至会引发错误。

>>> callable(list().__hash__)
False

自定义类型默认实现了 __hash__ 和 __eq__ 方法，用与哈希和相等比较操作。前者为每个实例返回随机值；后者除非与自己比较，否则总是返回 False。这两个方法可根据需要进行重载。

作为常用的数据结构，又因为命名空间的缘故，字典的使用频率非常高。Python 开发团队也一直致力于改进其数据结构和算法，这其中自然也包括惯用的缓存复用。

Python 3.6 借鉴 PyPy 字典设计，采用更紧凑的存储结构。keys.entries 和 values 用数组按添加顺序存储主键和值引用。实际哈希表由 keys.indices 数组承担，通过计算主键哈希值找到合适的位置，然后在该位置存储主键在 key.entries 的实际索引。如此一来，只要通过 indices 获取实际索引后，就可读取主键和值信息了。

虽然该版本按添加顺序存储元素，但内部实现不能作为依赖条件。在后续版本中，可能有其他变化。如有明确顺序需求，建议使用 collections.OrderDict。

系统分别缓存复用 80 个 dict 和 keys，其中包括长度为 8 的 entries 内存。对于大量小字典对象而言，直接使用，无须任何内存分配操作。回收时，凡内存被扩张过的都会被放弃。

从开发地址法（open-address）实现方式来看，它并不适合处理大数据。轻量级方案可选用 shelve、dbm 等标准库模块，也可直接采用 SQLite、LevelDB 等专业数据库。

构建

创建字典对象可以使用大括号键值对方式创建，或调用类型构造。

>>> {"a": 1, "b": 2}
{'a': 1, 'b': 2}
>>> dict(a=1, b=2)
{'a': 1, 'b': 2}

初始化键值参数也可以用元组、列表等可迭代对象的方式提供。

>>> kvs = (("a", 1), ["b", 2])
>>> dict(kvs)
{'a': 1, 'b': 2}

基于动态数据创建时，多以 zip、map 函数或推导式完成。

>>> dict(zip("abc", range(3)))
{'a': 0, 'b': 1, 'c': 2}
>>> dict(map(lambda k, v: (k, v + 10), "abc", range(3)))
{'a': 10, 'b': 11, 'c': 12}
>>> {k: v + 10 for k, v in zip("abc", range(3))}
{'a': 10, 'b': 11, 'c': 12}

除了直接提供内容外，某些时候，还须根据一定条件初始化字典对象。比如，基于已有字典内容扩展，或初始化零值等。

>>> a = {"a": 1}
>>> b = dict(a, b=1)        # 在复制 a 内容的基础上，新增键值对
>>> b
{'a': 1, 'b': 1}
>>> c = dict.fromkeys(b, 0)     # 仅用 b 的主键，内容另设
>>> c
{'a': 0, 'b': 0}
>>> d = dict.fromkeys(("counter1", "counter2"), 0)  # 显示提供主键
>>> d
{'counter1': 0, 'counter2': 0}

相比于 fromkeys 方法，推导式可完成更复杂的操作，比如额外的 if 过滤条件。

操作

字典不是序列类型，不支持序号访问，可以使用主键（键值）读取、新增或删除内容。
若主键（键值）不存在，会引发 KeyError 异常，可以先用 in、not in 语句判断是否存在该主键（键值），或用 get 方法返回默认值。

get 方法默认值参数仅返回，不影响字典内容。但某些时候，我们还须向字典插入默认值，比如用字典存储多个计数器，那么在第一次取值时延迟初始化很有必要。在字典内有零值内容代表该计数曾被使用，没有则无法记录该行为。

>>> x = {}
>>> x.setdefault("a", 0)        # 如果有 a，那么返回实际内容，否则新增{a:0}键值对
0
>>> x
{'a': 0}
>>> x["a"] = 100
>>> x.setdefault("a", 0)
100

字典不支持加法、乘法、大小等运算，但可比较内容是否相同。

>>> {"a": 1, "b": 2} == {"a": 1, "b": 2}
True

视图

与早期版本复制数据并返回列表不同，Python 3 默认以视图关联字典内容。如此一来，既能避免复制开销，还能同步观察字典变化。

>>> x = dict(a = 1, b = 2)
>>> ks = x.keys()       # 主键视图
>>> for k in ks: print(k, x[k])     # 利用视图迭代字典
a 1
b 2

<u>::这一段代码不是很明白，迭代获取值还是从原来的字典中获取的，为什么会叫视图呢？::</u>

字典没有独立的只读版本，无论传递引用还是复制品，都存在弊端：

• 直接引用有被接收方修改内容的风险
• 复制品仅是一次快照，无法获知字典的变化

视图则不同，它能同步读取字典内容，却无法修改。且可选择不同粒度的内容进行传递，如此可将接收方限定为指定模式下的观察员。

def test(d):        # 传递键值视图（items），只能读取，无法修改
    for k, v in d:
        print(k, v)

视图还支持集合操作，以弥补字典功能上的不足。

>>> a = dict(a = 1, b = 2)
>>> b = dict(c = 3, b = 2)
>>> ka = a.keys()
>>> kb = b.keys()

>>> ka & kb     # 交集：在 a、b 中同时存在
{'b'}
>>> ka | kb     # 并集：在 a 或 b 中存在
{'b', 'a', 'c'}
>>> ka - kb     # 差集：仅在 a 中存在
{'a'}
>>> ka ^ kb     # 对称差集：仅在 a 或仅在 b 中出现，相当于“并集-交集”
{'a', 'c'}

利用视图的集合运算，可简化某些操作。例如，只更新，不新增。

>>> a = dict(a = 1, b = 2)
>>> b = dict(b = 20, c = 3)

>>> ks = a.keys() & b.keys()        # 交集，也就是 a 中必须存在的主键

>>> a.update({k: b[k] for k in ks}) # 利用交集结果提取待更新的内容
>>> a
{'a': 1, 'b': 20}

拓展

在标准库中，还有几个扩展类型的字典可供使用。

默认字典（defaultdict）类似于 setdefault 方法的包装。当主键不存在时，调用构造参数提供的工厂函数返回默认值。

将字典直接作为对外接口时，无法保证用户是否会调用 setdefault 或 get 方法。这样，默认字典的内置初始化行为就好于对用户做额外要求。

>>> import collections
>>> d = collections.defaultdict(lambda : 100)
>>> d["a"]
100
>>> d["b"] += 1
>>> d
defaultdict(<function <lambda> at 0x10bfb4f28>, {'a': 100, 'b': 101})

与内部实现无关，有序字典（OrderedDict）明确记录主键首次插入的次序。

任何时候都要避免依赖内部实现，或者说遵循“显式优于隐式”的规则。

>>> d = collections.OrderedDict()
>>> d["z"] = 1
>>> d["a"] = 2
>>> d["x"] = 3
>>> for k, v in d.items(): print(k, v)
z 1
a 2
x 3

与前面所说不同，计数器（Counter）对于不存在的主键返回零，但不会新增，即将主键添加到字典中。

可通过继承并重载 __miss__ 方法新增键值

>>> d = collections.Counter()
>>> d["a"]
0
>>> d["b"] += 1
>>> d
Counter({'b': 1})

链式字典（ChainMap）以单一接口访问多个字典内容，其自身并不存储数据。读操作按参数顺序依次查找各字典，但修改操作（新增、更新、删除）仅针对第一字典。

>>> a = dict(a = 1, b =2)
>>> a = dict(a = 1, b = 2)
>>> b = dict(b = 20, c = 30)
>>> x = collections.ChainMap(a, b)

>>> x["b"], x["c"]      # 按顺序命中
(2, 30)
>>> for k, v in x.items(): print(k, v)      # 遍历所有字典
b 2
a 1
c 30

>>> x["b"] = 999        # 更新，命中第一字典
>>> x["z"] = 888        # 新增，命中第一字典
>>> x
ChainMap({'a': 1, 'b': 999, 'z': 888}, {'b': 20, 'c': 30})

可利用链式字典设计多层次的上下文（context）结构。

合理的上下文类型，须具备两个基本特征。首先是继承，所有设置可被调用链的后续函数读取；其次是修改仅针对当前和后续逻辑，不应向无关的父级传递。如此，链式字典查找次序本身就是继承的体现，而修改操作被限制在当前第一字典中中，自然也不会影响父级字典的同名主键设置。