python基础1-5 ：collections.defaultdict 构建 multidict&&OrderedDict模块&&zip() 函数

python cookbook第一章第6-9节

1.6 字典中的键映射多个值

问题: 怎样实现一个键对应多个值的字典（也叫 multidict）？

解决方案 : 一个字典就是一个键对应一个单值的映射。 如果你想要一个键映射多个值，那么你就需要将这多个值放到另外的容器中，比如列表或者集合里面。比如，你可以像下面这样构造这样的字典：

d = {
    'a' : [1, 2, 3],
    'b' : [4, 5]
}
e = {
    'a' : {1, 2, 3},
    'b' : {4, 5}
}

选择使用列表还是集合取决于你的实际需求。

1. 如果你想保持元素的插入顺序就应该使用列表，
2. 如果想去掉重复元素就使用集合（并且不关心元素的顺序问题）。

你可以很方便的使用collections 模块中的 defaultdict 来构造这样的字典。
defaultdict 的一个特征是它会自动初始化每个 key 刚开始对应的值，所以你只需要关注添加元素操作了。比如：

from collections import defaultdict
​
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
d   #defaultdict(list, {'a': [1, 2], 'b': [4]})
​
d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)
d   #defaultdict(set, {'a': {1, 2}, 'b': {4}})

需要注意的是， defaultdict 会自动为将要访问的键（就算目前字典中并不存在这样的键）创建映射实体。
如果你并不需要这样的特性，你可以在一个普通的字典上使用 setdefault() 方法来代替。比如：

d = {} # 一个普通的字典
d.setdefault('a', []).append(1)
d.setdefault('a', []).append(2)
d.setdefault('b', []).append(4)
​
d   #{'a': [1, 2], 'b': [4]}
type(d)  #dict

但是很多程序员觉得 setdefault()用起来有点别扭。因为每次调用都得创建一个新的初始值的实例（例子程序中的空列表 [] ）。

讨论

一般来讲，创建一个多值映射字典是很简单的。但是，如果你选择自己实现的话，那么对于值的初始化可能会有点麻烦， 你可能会像下面这样来实现：

d = {}
for key, value in pairs:
    if key not in d:
        d[key] = []
    d[key].append(value)
    
# 如果使用 defaultdict 的话代码就更加简洁了：

d = defaultdict(list)
for key, value in pairs:
    d[key].append(value)

这一小节所讨论的问题跟数据处理中的记录归类问题有大的关联。可以参考 1.15 小节的例子。

---

1.7 字典排序

问题: 你想创建一个字典，并且在迭代或序列化这个字典的时候能够控制元素的顺序。

解决方案: 为了能控制一个字典中元素的顺序，你可以使用 collections 模块中的 OrderedDict 类。在迭代操作的时候它会保持元素被插入时的顺序，

示例如下：

from collections import OrderedDict

d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['grok'] = 4

for key in d:
    print(key, d[key])
# Outputs "foo 1", "bar 2", "spam 3", "grok 4"

当你想要构建一个将来需要序列化或编码成其他格式的映射的时候，OrderedDict是非常有用的。 比如，你想精确控制以 JSON 编码后字段的顺序，你可以先使用 OrderedDict 来构建这样的数据：

import json
json.dumps(d)

讨论
OrderedDict 内部维护着一个根据键插入顺序排序的双向链表。
每次当一个新的元素插入进来的时候，它会被放到链表的尾部。
对于一个已经存在的键的重复赋值不会改变键的顺序。

需要注意的是，一个 OrderedDict 的大小是一个普通字典的两倍，因为它内部维护着另外一个链表。
所以如果你要构建一个需要大量 OrderedDict 实例的数据结构的时候（比如读取 100,000 行 CSV 数据到一个 OrderedDict 列表中去），
那么你就得仔细权衡一下是否使用 OrderedDict 带来的好处要大过额外内存消耗的影响。

---

1.8 字典的运算

问题: 怎样在数据字典中执行一些计算操作（比如求最小值、最大值、排序等等）？

解决方案: 考虑下面的股票名和价格映射字典：

考虑下面的股票名和价格映射字典：

prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}

为了对字典值执行计算操作，通常需要使用 zip() 函数先将键和值反转过来。 比如，下面是查找最小和最大股票价格和股票值的代码：

min_price = min(zip(prices.values(), prices.keys()))
# min_price is (10.75, 'FB')
max_price = max(zip(prices.values(), prices.keys()))
# max_price is (612.78, 'AAPL')

类似的，可以使用 zip() 和 sorted() 函数来排列字典数据：

prices_sorted = sorted(zip(prices.values(), prices.keys()))
# prices_sorted is [(10.75, 'FB'), (37.2, 'HPQ'),
#                   (45.23, 'ACME'), (205.55, 'IBM'),
#                   (612.78, 'AAPL')]

执行这些计算的时候，需要注意的是 zip() 函数创建的是一个只能访问一次的迭代器。 比如，下面的代码就会产生错误：

prices_and_names = zip(prices.values(), prices.keys())
print(min(prices_and_names)) # OK
print(max(prices_and_names)) # ValueError: max() arg is an empty sequence

讨论

如果你在一个字典上执行普通的数学运算，你会发现它们仅仅作用于键，而不是值。比如：

min(prices) # Returns 'AAPL'
max(prices) # Returns 'IBM'

这个结果并不是你想要的，因为你想要在字典的值集合上执行这些计算。
或许你会尝试着使用字典的 values() 方法来解决这个问题：

min(prices.values()) # Returns 10.75
max(prices.values()) # Returns 612.78

不幸的是，通常这个结果同样也不是你想要的。
你可能还想要知道对应的键的信息（比如那种股票价格是最低的？）。

你可以在 min() 和 max() 函数中提供 key 函数参数来获取最小值或最大值对应的键的信息。比如：

min(prices, key=lambda k: prices[k]) # Returns 'FB'
max(prices, key=lambda k: prices[k]) # Returns 'AAPL'

但是，如果还想要得到最小值，你又得执行一次查找操作。比如：

min_value = prices[min(prices, key=lambda k: prices[k])]   #10.75

前面的 zip() 函数方案通过将字典”反转”为 (值，键) 元组序列来解决了上述问题。 当比较两个元组的时候，值会先进行比较，然后才是键。 这样的话你就能通过一条简单的语句就能很轻松的实现在字典上的求最值和排序操作了。

需要注意的是在计算操作中使用到了 (值，键) 对。当多个实体拥有相同的值的时候，键会决定返回结果。 比如，在执行 min() 和 max() 操作的时候，如果恰巧最小或最大值有重复的，那么拥有最小或最大键的实体会返回：

prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }

min(zip(prices.values(), prices.keys()))
#(45.23, 'AAA')

max(zip(prices.values(), prices.keys()))
#(45.23, 'ZZZ')

---

1.9 查找两字典的相同点

问题: 怎样在两个字典中寻寻找相同点（比如相同的键、相同的值等等）？

解决方案: 考虑下面两个字典：

a = {
    'x' : 1,
    'y' : 2,
    'z' : 3
}
​
b = {
    'w' : 10,
    'x' : 11,
    'y' : 2
}

为了寻找两个字典的相同点，可以简单的在两字典的 keys() 或者 items() 方法返回结果上执行集合操作。比如：

# Find keys in common
a.keys() & b.keys() # { 'x', 'y' }   #键视图对象相交
# Find keys in a that are not in b
a.keys() - b.keys() # { 'z' }        #键视图对象做差
# Find (key,value) pairs in common
​
a.items() & b.items() # { ('y', 2) }  #元素视图对象相交，用来查找两个字典有哪些相同的键值对

这些操作也可以用于修改或者过滤字典元素。 比如，假如你想以现有字典构造一个排除几个指定键的新字典。 下面利用字典推导来实现这样的需求：

# Make a new dictionary with certain keys removed
c = {key:a[key] for key in a.keys() - {'z', 'w'}}
# c is {'x': 1, 'y': 2}

讨论

一个字典就是一个键集合与值集合的映射关系。
字典的keys() 方法返回一个展现键集合的键视图对象。
键视图的一个很少被了解的特性就是它们也支持集合操作，比如集合并、交、差运算。
所以，如果你想对集合的键执行一些普通的集合操作，可以直接使用键视图对象而不用先将它们转换成一个 set。

字典的items() 方法返回一个包含 (键，值) 对的元素视图对象。
这个对象同样也支持集合操作，并且可以被用来查找两个字典有哪些相同的键值对。

尽管字典的 values() 方法也是类似，但是它并不支持这里介绍的集合操作。
某种程度上是因为值视图不能保证所有的值互不相同，这样会导致某些集合操作会出现问题。
不过，如果你硬要在值上面执行这些集合操作的话，你可以先将值集合转换成set，然后再执行集合运算就行了。
​