关于字典的更多秘密，也许你还不知道

让字典的键对应多个值

让字典中的一个键去对应多个值，其实这实现起来并不难。
比如，可以让它的值去对应一个容器，如列表、集合。

In [145]: info = {'name':['shark','qf']}

不过你可以选择更优雅的方法，使用 collections 模块中的 defaultdict 来构造这样的字典。

defaultdict 的一个特征是它会自动初始化每个 key 刚开始对应的值。

In [146]: from collections import defaultdict

In [147]: d = defaultdict(list)

In [148]: d['name'].append("shark")

In [149]: d['name'].append("QF")

In [150]: d
Out[150]: defaultdict(list, {'name': ['shark', 'QF']})

In [151]: d.get('name')
Out[151]: ['shark', 'QF']

还有在一个现有的字典中使用 setdefault 来实现。

In [3]: d = {}

In [4]: d.setdefault('a',[]).append(1)

In [5]: d.setdefault('a',[]).append(2)

In [6]: d
Out[6]: {'a': [1, 2]}

字典的 setdefault 方法可以把字典中不存在的键设置到字典中，键对应的值就是 setdefault 的第二个参数。

但是假如一个 key 本来就存在于字典中，那么将会获取到这个 key 目前对应的值，也就是说现有的值不会被覆盖。

In [7]: e = {'b': [10],'c': 'hello'}

In [8]: e.setdefault('b', [])
Out[8]: [10]

In [9]: e.setdefault('c', [])
Out[9]: 'hello'

有序字典

collections 模块中的 OrderedDict 可以创建一个有序的字典，它可以保持键值对最初添加到字典中的顺序。

In [19]: from collections import OrderedDict

In [20]: u = OrderedDict()

In [21]: u
Out[21]: OrderedDict()

In [22]: u['a'] = 10

In [23]: u['c'] = 10

In [24]: u['f'] = 10

In [25]: u['b'] = 10

In [26]: u
Out[26]: OrderedDict([('a', 10), ('c', 10), ('f', 10), ('b', 10)])

In [27]: for k, v in u.items():
    ...:     print(k, v)
    ...:
a 10
c 10
f 10
b 10

利用 OrderedDict 和 sorted() 内置函数，可以对一个已有的字典进行排序。

In [28]: f = {'a': 10, 'b': 2, 'c': 30, 'e': 1, 'f': 8}

In [29]: f = OrderedDict(sorted(f.items(), key=lambda item: item[1]))

In [30]: f
Out[30]: OrderedDict([('e', 1), ('b', 2), ('f', 8), ('a', 10), ('c', 30)])

倒序

 f = OrderedDict(sorted(f.items(), key=lambda item: item[1], reverse=True))

OrderedDict 内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的 元素插入进来的时候，它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会 改变键的顺序。
需要注意的是，一个 OrderedDict 的大小是一个普通字典的两倍，因为它内部维 护着另外一个链表。

字典的计算

如何求出字典中最大的值或者最小值, 可以利用内置函数 zip()

In [34]: prices = {
    ...:     'ACME': 45.23,
    ...:     'AAPL': 612.78,
    ...:     'IBM': 205.55,
    ...:     'HPQ': 37.20,
    ...:     'FB': 10.75
    ...: }

In [35]: min_price = min(zip(prices.values(), prices.keys()))

In [36]: min_price
Out[36]: (10.75, 'FB')

In [37]: max_price = max(zip(prices.values(), prices.keys()))

In [38]: max_price
Out[38]: (612.78, 'AAPL')

还以利用 zip() 更优雅的实现排序。

In [39]: prices_sorted = sorted(zip(prices.values(), prices.ke
    ...: ys()))

In [40]: prices_sorted
Out[40]:
[(10.75, 'FB'),
 (37.2, 'HPQ'),
 (45.23, 'ACME'),
 (205.55, 'IBM'),
 (612.78, 'AAPL')]
 
 In [41]: for p, m in prices_sorted:
    ...:     print(m, p)
    ...:
FB 10.75
HPQ 37.2
ACME 45.23
IBM 205.55
AAPL 612.78

需要注意的是 zip() 函数创建的是一个只能访问一次的迭代器。

等等，也许你在某种情况下，并不太在意具体的价格，只想看那个股票最低。就是只关心股票名。
那告诉你， 内置函数 min() 和 max() 也都接收一个 key 的关键字参数。

In [49]: min(prices, key=lambda k: prices[k])
Out[49]: 'FB'

In [50]: max(prices, key=lambda k: prices[k])
Out[50]: 'AAPL'

其实，不难发现 min 和 max 都是作用于字典的 key。

---

查找两个字典的相同点和不同点

比如有这样两个字典

In [50]: d = {'a': 1, 'b': 2, 'c': 3}

In [51]: e = {'b': 2,'c': 'hello', 'e': 6}

我想找出他们的相同点 key 或者 不同的 key， 其实字典的 keys() 和 items() 有个少有人知的特性，就是它们都支持集合运算。

In [52]: d.keys() & e.keys()  # 相同的 key
Out[52]: {'b', 'c'}

In [53]: d.keys() - e.keys()  # d 独有的 key
Out[53]: {'a'}

In [54]: d.keys() | e.keys()  # 合起来的 key
Out[54]: {'a', 'b', 'c', 'e'}

In [55]: d.items() & e.items()  # 相同点键值对
Out[55]: {('b', 2)}

In [56]: d.items() - e.items()
Out[56]: {('a', 1), ('c', 3)}

In [57]: d.items() | e.items()
Out[57]: {('a', 1), ('b', 2), ('c', 'hello'), ('c', 3), ('e', 6)}

未完, 待续...