关于字典的更多秘密，也许你还不知道
让字典的键对应多个值
让字典中的一个键去对应多个值，其实这实现起来并不难。
比如，可以让它的值去对应一个容器，如列表、集合。
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)}
未完, 待续...
