Python 字典

快来打我* 2022-07-15 02:51 239阅读 0赞

字典 (dict) 采⽤用开放地址法的哈希表实现。  
• ⾃自带元素容量为 8 的 smalltable，只有 "超出" 时才到堆上额外分配元素表内存。  
• 虚拟机缓存 80 个字典复⽤用对象，但在堆上分配的元素表内存会被释放。  
• 按需动态调整容量。扩容或收缩操作都将重新分配内存，重新哈希。  
36  
• 删除元素操作不会⽴立即收缩内存。  
创建字典：  
>>> \{\}? ? ? ? ? ? ? \# 空字典  
\{\}  
>>> \{"a":1, "b":2\}? ? ? ? ? \# 普通构造⽅方式  
\{'a': 1, 'b': 2\}  
>>> dict(a = 1, b = 2)? ? ? ? \# 构造  
\{'a': 1, 'b': 2\}  
>>> dict((\["a", 1\], \["b", 2\]))? ? ? \# ⽤用两个序列类型构造字典。  
\{'a': 1, 'b': 2\}  
>>> dict(zip("ab", range(2)))? ? ? \# 同上  
\{'a': 0, 'b': 1\}  
>>> dict(map(None, "abc", range(2)))? ? \# 同上  
\{'a': 0, 'c': None, 'b': 1\}  
>>> dict.fromkeys("abc", 1)? ? ? \# ⽤用序列做 key，并提供默认 value。  
\{'a': 1, 'c': 1, 'b': 1\}  
>>> \{k:v for k, v in zip("abc", range(3))\}? \# 使⽤用⽣生成表达式构造字典。  
\{'a': 0, 'c': 2, 'b': 1\}  
基本操作：  
>>> d = \{"a":1, "b":2\}  
>>> "b" in d?? ? ? ? ? \# 判断是否包含 key。  
True  
>>> d = \{"a":1, "b":2\}  
>>> del d\["b"\]? ? ? ? ? \# 删除 k/v。  
>>> d  
\{'a': 1\}  
>>> d = \{"a":1\}  
>>> d.update(\{"c": 3\})? ? ? ? \# 合并 dict。  
>>> d  
\{'a': 1, 'c': 3\}  
>>> d = \{"a":1, "b":2\}  
>>> d.pop("b")? ? ? ? ? \# 弹出 value。  
>>> d  
(2, \{'a': 1\})  
37  
>>> d = \{"a":1, "b":2\}  
>>> d.popitem()? ? ? ? ? \# 弹出 (key, value)。  
('a', 1)  
默认返回值：  
>>> d = \{"a":1, "b":2\}  
>>> d.get("c")? ? ? ? ? \# 如果没有对应 key，返回 None。  
None  
>>> d.get("d", 123)? ? ? ? ? \# 如果没有对应 key，返回缺省值。  
123  
>>> d.setdefault("a", 100)? ? ? ? \# key 存在，直接返回 value。  
1  
>>> d.setdefault("c", 200) ? ? ? \# key 不存在，先设置，后返回。  
200  
>>> d?  
\{'a': 1, 'c': 200, 'b': 2\}  
迭代器操作：  
>>> d = \{"a":1, "b":2\}  
>>> d.keys()  
\['a', 'b'\]  
>>> d.values()  
\[1, 2\]  
>>> d.items()? ?  
\[('a', 1), ('b', 2)\]  
>>> for k in d: print k, d\[k\]  
a 1  
b 2  
>>> for k, v in d.items(): print k, v  
a 1  
b 2  
对于⼤大字典，调⽤用 keys()、values()、items() 会构造同样巨⼤大的列表。建议⽤用迭代器替代，以减  
少内存开销。  
38  
>>> d = \{"a":1, "b":2\}  
>>> d.iterkeys()  
<dictionary-keyiterator object at 0x10de82cb0>  
>>> d.itervalues()  
<dictionary-valueiterator object at 0x10de82d08>  
>>> d.iteritems()  
<dictionary-itemiterator object at 0x10de82d60>  
>>> for k, v in d.iteritems():  
... print k, v  
a 1  
b 2  
视图  
要判断两个字典间的差异，使⽤用视图是最简便的做法。  
>>> d1 = dict(a = 1, b = 2)  
>>> d2 = dict(b = 2, c = 3)  
>>> d1 & d2? ? ? ? ? \# 字典不⽀支持该操作。  
TypeError: unsupported operand type(s) for &: 'dict' and 'dict'  
>>> v1 = d1.viewitems()  
>>> v2 = d2.viewitems()  
>>> v1 & v2? ? ? ? ? \# 交集  
set(\[('b', 2)\])  
>>> v1 | v2? ? ? ? ? \# 并集  
set(\[('a', 1), ('b', 2), ('c', 3)\])  
>>> v1 - v2? ? ? ? ? \# 差集 (仅 v1 有，v2 没有的)  
set(\[('a', 1)\])  
>>> v1 ^ v2? ? ? ? ? \# 对称差集 (不会同时出现在 v1 和 v2 中)  
set(\[('a', 1), ('c', 3)\])  
>>> ('a', 1) in v1? ? ? ? \# 判断  
True  
视图让某些操作变得更加简便，⽐比如在不引⼊入新数据项的情况下更新字典内容。  
>>> a = dict(x=1)  
>>> b = dict(x=10, y=20)  
39  
>>> a.update(\{k:b\[k\] for k in a.viewkeys() & b.viewkeys()\})  
>>> a  
\{'x': 10\}  
视图会和字典同步变更。  
>>> d = \{"a": 1\}  
>>> v = d.viewitems()  
>>> v  
dict\_items(\[('a', 1)\])  
>>> d\["b"\] = 2  
>>> v  
dict\_items(\[('a', 1), ('b', 2)\])  
>>> del d\["a"\]  
>>> v  
dict\_items(\[('b', 2)\])  
扩展  
当访问的 key 不存在时， defaultdict ⾃自动调⽤用 factory 对象创建所需键值对。factory 可以是任  
何⽆无参数函数或 callable 对象。  
>>> from collections import defaultdict  
>>> d = defaultdict(list)  
>>> d\["a"\].append(1)? \# key "a" 不存在，直接⽤用 list() 函数创建⼀一个空列表作为 value。  
>>> d\["a"\].append(2)  
>>> d\["a"\]  
\[1, 2\]  
字典是哈希表，默认迭代是⽆无序的。如果希望按照元素添加顺序输出结果，可以⽤用 OrderedDict。  
>>> from collections import OrderedDict  
>>> d = dict()  
>>> d\["a"\] = 1  
>>> d\["b"\] = 2  
>>> d\["c"\] = 3  
>>> for k, v in d.items(): print k, v? ? \# 并⾮非按添加顺序输出。  
a 1  
c 3  
b 2  
>>> od = OrderedDict()  
40  
>>> od\["a"\] = 1  
>>> od\["b"\] = 2  
>>> od\["c"\] = 3  
>>> for k, v in od.items(): print k, v?? \# 按添加顺序输出。  
a 1  
b 2  
c 3  
>>> od.popitem()? ? ? ? ? \# 按 LIFO 顺序弹出。  
('c', 3)  
>>> od.popitem()  
('b', 2)  
>>> od.popitem()  
('a', 1)