Python3 CookBook| 数据结构和算法（一）

以下测试代码全部基于 Python3。

Python 提供了大量的内置数据结构，包括列表，集合以及字典。在工作和编码中，可以说天天和它们打交道，经常碰到查询，排序和过滤等等这些问题，虽然每次解决这些问题并不困难，但总感觉代码写的很麻烦，不够优雅。

最近通过阅读《Python3 CookBook》，了解了一些更优秀的方法，做一些简单记录，与大家分享

1.解压可迭代对象赋值给多个变量

我们都知道，一个序列是可以赋值给多个变量的，就像下面这样：

In [7]: p = (1, 2, 3)

In [8]: x, y, z = p

In [9]: x
Out[9]: 1

但是如果接受变量个数和序列个数不一致，就会报错，如果你不知道元素个数的话，可以采用下面这样的方式：

In [10]: x, *y = p

In [11]: y
Out[11]: [2, 3]

通过这种星号的方式，就可以解压不确定个数或任意个数的可迭代对象了，是不是很棒呢？
那么，用这个方法可以解决哪些问题呢？
先来看一种情况，现在有一个序列，去掉第一个数和最后一个数，然后求剩下数的平均值。
这个问题很简单，我的第一反应是循环求和，然后计算平均值，显然很麻烦。这时候星号表达式就派上用场了：

def drop_first_last(items):
  first, *middle, last = items
  return avg(middle)

再看一种情况，比如字符串的分割：

In [12]: line = 'drwxr-xr-x  41 zyx  staff   1.4K 11 24 08:53 zyx'

In [13]: info, *fields, homedir = line.split(' ')

In [14]: info
Out[14]: 'drwxr-xr-x'

In [15]: homedir
Out[15]: 'zyx'

2.保留最后N个元素

这个问题也是经常会遇到的，比如只取文件中满足要求的前五行，或者只返回满足要求的最新十条数据。我的第一反应是列表，然后通过 push 和 pop 来操作列表来实现。
其实通过 collections.deque 可以很容易解决这个问题，使用 deque(maxlen=N) 构造函数新建一个固定大小的队列。当新元素加入并且这个队列已满时，最先进入队列的元素便会被移除，符合先进先出的原则。
。

In [16]: from collections import deque

In [17]: q = deque(maxlen=3)

In [18]: q.append(1)

In [19]: q.append(2)

In [20]: q.append(3)

In [21]: q
Out[21]: deque([1, 2, 3])

In [22]: q.append(4)

In [23]: q
Out[23]: deque([2, 3, 4])

如果没有设置 maxlen 则是一个无限大小的队列，可以通过 appendleft 和 pop 在队首和队尾添加删除元素。

3.字典中的键映射多个值

现在有一个需求 ，构建一个字典，key是用户ID，value为一个列表，列表元素可以使名字，电话等等，大概是这样：

d = {'id': ['name', 'phone']}

如果我们自己构建字典，可能会向下面这样来实现：

d = {}
for key, value in items:
  if key not in d:
    d[key] = value
  d[key].append(value)

很麻烦，如果使用 collections 的 defaultdict 就很简单了。defaultdict 的一个特征就是它会自动初始化每个 key 刚开始对应的值，所以我们只关注添加元素操作就可以了。

优化后代码就变成了这样：

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

4.字典排序

字典是无序的，但如果需要控制字典中元素的顺序呢？可以使用collections 中的OrderedDict，如下：

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

for key in d:
  print(key, d[key])

OrderedDict内部维护这一根据键插入顺序排序的双向链表，每次新元素插入时，便会被放在链表尾部，对于已经存在的键，并不会改变键的顺序。

但需要注意的是，OrderedDict的大小是普通字典的两倍，所以在构建一个需要大量 OrderedDict实例的数据结构时，就要考虑大量内存消耗的影响了。

5.字典的运算

如何取出字典中的最小值，或者对字典进行排序呢？
首先我们来看看普通数学运算函数

In [25]: d = {'a': 11, 'b': 43, 'c': 3, 'd': 65}

In [26]: min(d)
Out[26]: 'a'

他比较的逻辑是直接比较key， 然后取出对应的 key，但如果要比较value呢？

In [28]: min(d.values())
Out[28]: 3

结果是正确的，但似乎并不完美，如果键值一起返回就完美了。这时候就该 zip 登场了，它的作用是可以使键和值反转过来。

In [29]: min(zip(d.values(), d.keys()))
Out[29]: (3, 'c')

它直接返回了值最小的键和值，这样就很好了，不管需要哪个信息都可以直接使用。如果要对这个字典排序的话也很简单：

In [34]: sorted(zip(d.values(), d.keys()))
Out[34]: [(3, 'c'), (11, 'a'), (43, 'b'), (65, 'd')]

6.合并多个字典或映射

现在有多个字典或者映射，你想它们从逻辑上合并为一个单一的映射后执行某些操作，比如查找值或者检查某些键是否存在。

解决方案：
假设你有如下两个字典：

a = {'x': 1, 'z': 3}
b = {'y': 2, 'z': 4}

现在假设你必须在两个字典中执行查找操作（比如先从a中查找，如果找不到再在b中找）。一个非常简单的解决方案就是使用collections模块中的ChainMap类。比如：

from collections import ChainMap
c = ChainMap(a,b)
print(c['x'])   # Outputs 1 (from a)
print(c['y'])   # Outputs 2 (from b)
print(c['z'])   # Outputs 3 (from a)

一个ChainMap接受多个字典并将它们在逻辑上变成一个字典。这些字典并不是真的合并在一起了，ChainMap类只是在内部创建了一个容纳字典的列表并重新定义了一些常见的字典操作来遍历这个列表。大部分字典操作都可以正常使用。

如果出现重复键，那么第一次出现的映射值会被返回。因此，例子程序中c['z']总是返回字典a中的值，而不是b中对应的值。

对字典的的更新或删除操作总是影响的是列表的第一个字典。比如：

>>> c['z'] = 10
>>> c['w'] = 40
>>> del c['x']
>>> a
{'w': 40, 'z': 10}
>>> del c['y']
Traceback (most recent call last):
...
KeyError: "Key not found in the first mapping: 'y'"
>>>