collections 模块整理

deque类

collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加或者删除元素的数据类型。而且如果想要有一种数据类型来存放“最近用到的几个元素”， deque 也是一个很好的选择。这是因为在新建一个双向队列的时候，你可以指定这个队列的大小，如果这个队列满员了，还可以从反向端删除过期的元素，然后在尾端添加新的元素。

deque(maxlen=N)创建一个固定长度的队列，当有新的记录加入到已满的队列时会自动移除最老的那条记录。

>>> from collections import deque>>> q = deque(range(5), maxlen=5)>>> qdeque([0, 1, 2, 3, 4], maxlen=5)>>> q.append(5)>>> qdeque([1, 2, 3, 4, 5], maxlen=5)>>> q.rotate(3)>>> qdeque([3, 4, 5, 1, 2], maxlen=5)>>> q.appendleft(-1)>>> qdeque([-1, 3, 4, 5, 1], maxlen=5)>>> q.extendleft([11,22,33])>>> qdeque([33, 22, 11, -1, 3], maxlen=5)

• maxlen 是一个可选参数，代表这个队列可以容纳的元素的数量，而且一旦设定，这个属性就不能修改了。
• 队列的旋转操作接受一个参数 n ，当 n > 0 时，队列的最右边的 n 个元素会被移动到队列的左边。当 n < 0 时，最左边的 n 个元素会被移动到右边。
• 当试图对一个已满（ len(d) == d.maxlen ）的队列做尾部添加操作的时候，它头部的元素会被删除掉。
• extendleft(iter) 方法会把迭代器里的元素逐个添加到双向队列的左边，因此迭代器里的元素会逆序出现在队列里。

Counter

collections.Counter这个映射类型会给键准备一个整数计数器。每次更新一个键的时候都会增加这个计数器。所以这个类型可以用来给可散列表对象计数，或者是当成多重集来用——多重集合就是集合里的元素可以出现不止一次。 Counter 实现了 + 和 - 运算符用来合并记录，还有像most_common([n])这类很有用的方法， most_common([n]) 会按照次序返回映射里最常见的 n 个键和它们的计数，官方文档。

>>> from collections import Counter>>> c = Counter('asdasdafdsafsadfdsdgxcvsfdagvv')>>> cCounter({'d': 7, 'a': 6, 's': 6, 'f': 4, 'v': 3, 'g': 2, 'x': 1, 'c': 1})>>> c.update('wdaaffdsfsdfsa')>>> cCounter({'d': 10, 'a': 9, 's': 9, 'f': 8, 'v': 3, 'g': 2, 'x': 1, 'c': 1, 'w': 1})

关于Counter一个不为人知的特性，那就是它们可以轻松的同各种数学运算操作结合起来使用，如：

这里写代码片

defaultdict

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict>>> d = defaultdict(list)>>> d['a'][]>>> d['a'].append(1)>>> ddefaultdict(<class 'list'>, {'a': [1]})>>> d['a'].append(2)>>> d['b'].append(4)>>> ddefaultdict(<class 'list'>, {'a': [1, 2], 'b': [4]})>>> s = 'mississippi'>>> d = defaultdict(int)>>> for k in s:     d[k] += 1>>> sorted(d.items())[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict。当对字典做迭代时候，它会严格按照元素初始添加的顺序进行。

>>> from collections import OrderedDict>>> d = OrderedDict()>>> dOrderedDict()>>> d['foo'] = 1>>> d['bar'] = 2>>> d['spam'] = 3>>> d['grok'] = 4>>> for key in d:...     print(key, d[key])...foo 1bar 2spam 3grok 4

OrderedDict内部维护了一个双向链表，它会根据元素的加入顺序来排列键的位置。第一个新加入的元素会被放置在链表的末尾，接下来对已存在的键进行赋值时不会改变键的顺序。

• 就没
• 流

namedtuple

collections.namedtuple 是一个工厂函数，它可以用来构建一个带字段名的元组和一个有名字的类——这个带名字的类对调试程序有很大帮助。

>>> from collections import namedtuple>>> P = namedtuple('P', 'x y')>>> p = P(1,2)>>> p.x1>>> p.y2

>>> from collections import namedtuple>>> City = namedtuple('City', 'name country population coordinates')>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))>>> tokyoCity(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722,139.691667))>>> tokyo.population36.933>>> tokyo.coordinates(35.689722, 139.691667)>>> tokyo[1]'JP'

创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。

ChainMap

该类型可以容纳数个不同的映射对象，然后在进行键查找操作的时候，这些对象会被当作一个整体被逐个查找，直到键被找到为止。这个功能在给有嵌套作用域的语言做解释器的时候很有用，可以用一个映射对象来代表一个作用域的上下文。

>>> from collections import ChainMap>>> a = {'x': 1, 'y': 2}>>> b = {'y': 3 , 'z': 4}>>> c = ChainMap(a, b)>>> cChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})

ChainMap可以接受多个映射然后在逻辑上使它们表现为一个单独的映射结构。但是，这些映射在字面上并不会合并在一起。相反，ChainMap只是简单的维护一个记录底层映射关系的列表，然后重新定义常见的字典操作来扫描这个列表。大部分的操作都可以正常的工作。

>>> len(c)3>>> c.keys()KeysView(ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4}))>>> c.values()ValuesView(ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4}))>>> c['x']1>>> c['y']2

如果与重复的键，那么这里会采用第一个映射中所对应的键值。
修改映射的操作总会作用在列出的第一个映射结构上。

>>> c['y'] = 22>>> c['z'] = 9>>> del c['x']>>> a{'y': 22, 'z': 9}>>> cChainMap({'y': 22, 'z': 9}, {'y': 3, 'z': 4})

注：ChainMap使用的是原始的字典，也就是说如果任一个原始的字典发生了变化，那么合并之后的字典也将会发生变化

>>> a['a'] = 4>>> a{'y': 22, 'z': 9, 'a': 4}>>> cChainMap({'y': 22, 'z': 9, 'a': 4}, {'y': 3, 'z': 4})

而作为ChainMap的替代方案，可能会考虑到利用字典的update()方法将多个字典合并在一起。

>>> a{'y': 22, 'z': 9, 'a': 4}>>> b{'x':3}>>> merged = dict(b)>>> merged.update(a)>>> merged{'y': 22, 'z': 9, 'a': 4, 'x': 3}>>>

但是，如果其中任意一个原始字典发生了改变，这个改变都不会反应到合并后的字典中。

>>> a['x'] = 5>>> a{'y': 22, 'z': 9, 'a': 4, 'x': 5}>>> b{'x': 3}>>> merged{'y': 22, 'z': 9, 'a': 4, 'x': 3}