欢迎加入 Python 官方文档翻译团队：https://www.transifex.com/python-doc/
collections 模块实现了特定目标的容器，以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。
collections 模块官方文档：https://docs.python.org/3/library/collections.html
部分常用函数：1、collections.namedtuple()2、collections.deque()3、collections.defaultdict()4、collections.OrderedDict()5、collections.ChainMap()6、collections.Counter()
1、collections.namedtuple()
该函数主要功能是：命名元组赋予每个位置一个含义，提供可读性和自文档性。
基本语法：collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
typename：类名称，即通过 namedtuple 创建的一个元组的子类的类名
field_names：字段名称，结构类似于 [‘x’, ‘y’] 一样的字符串序列。也可以是一个纯字符串，用空白或逗号分隔开元素名，比如 ‘x y’ 或者 ‘x, y’，实际上类似于字典的 key，定义的元组可以通过这样的 key 去获取里面对应索引位置的元素值。
rename：如果 rename 指定为 True，那么 field_names 就不能包含非 Python 标识符、Python 中的关键字以及重复的 name，如果有，将会默认重命名为 ‘_index’ 的样式，index 表示该 name 在 field_names 中的索引，例：['abc', 'def', 'ghi', 'abc'] 将被转换成 ['abc', '_1', 'ghi', '_3']。
应用举例：
>>> import collections>>> point = collections.namedtuple('point', ['x', 'y'])>>> p = point(1, 2) # 使用位置参数初始化namedtuple>>> p.x # 使用对应字段名字获取namedtuple里面的元素1>>> p.y2>>> m = point(x=5, y=6) # 使用关键字参数初始化namedtuple>>> m[0] # 使用索引获取 namedtuple 里面的元素5>>> m[1]6 2、collections.deque()使用列表（list）存储数据时，按索引访问元素很快，但插入和删除元素却很慢，因为列表是线性存储，数据量大的时候，插入和删除效率很低，而 deque 恰好可以解决这个问题，实现了高效插入和删除操作。
deque 是双边队列（double-ended queue），具有队列和栈的性质，在列表的基础上增加了移动、旋转和增删等。
基本语法：collections.deque([iterable[, maxlen]])
deque 对象支持以下方法：
方法功能append(x)添加 x 到最右端appendleft(x)添加 x 到最左端clear()移除所有元素，使其长度为 0copy()创建一份浅拷贝count(x)计算 deque 中元素等于 x 的个数extend(iterable)添加 iterable 参数中的所有元素到最右端extendleft(iterable)添加 iterable 参数中的所有元素到最左端注意，左添加时，结果中 iterable 参数中的顺序将被反过来添加index(x[, start[, stop]])返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前）返回第一个匹配项，如果未找到则引发 ValueErrorinsert(i, x)在位置 i 插入 x，如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发 IndexErrorpop()移去 deque 最右边的元素并返回该元素，若没有该元素，则引发 IndexError 索引错误popleft()移去 deque 最左边的元素并返回该元素，若没有该元素，则引发 IndexError 索引错误remove(value)移去找到的第一个 value，若没有该元素，则引发 ValueErrorreverse()将 deque 逆序排列rotate(n)向右循环移动 n 步，如果 n 是负数，就向左循环若 deque 不为空，向右循环移动一步等价于d.appendleft(d.pop()) 向左循环一步等价于d.append(d.popleft())应用举例：
>>> import collections>>> d = collections.deque(['a', 'b', 'c', 'd'])>>> d.append('e') # 添加一个元素 'e' 到最右端>>> print(d)deque(['a', 'b', 'c', 'd', 'e'])>>> d.appendleft('f') # 添加一个元素 'f' 到最左端>>> print(d)deque(['f', 'a', 'b', 'c', 'd', 'e'])>>> d.clear() # 移除所有元素>>> print(d)deque([])>>> d = collections.deque(['1', '2', '3', '2'])>>> print(d.count('2')) # 计算元素 '2' 的个数2>>> d.extend(['a', 'b', 'c']) # 添加一个列表的所有元素到最右端>>> print(d)deque(['1', '2', '3', '2', 'a', 'b', 'c'])>>> d.extendleft(['A', 'B', 'C']) # 添加一个列表的所有元素到最左端>>> print(d)deque(['C', 'B', 'A', '1', '2', '3', '2', 'a', 'b', 'c'])>>> print(d.index('2',0,5)) # 在 0 - 5 索引范围内查找元素 '2' 的位置4>>> d.insert(2, 'D') # 在索引值为 2 处插入元素 'D'>>> print(d)deque(['C', 'B', 'D', 'A', '1', '2', '3', '2', 'a', 'b', 'c'])>>> d.pop() # 移除最右边的元素并返回该元素'c'>>> print(d)deque(['C', 'B', 'D', 'A', '1', '2', '3', '2', 'a', 'b'])>>> d.popleft() # 移除最左边的元素并返回该元素'C'>>> print(d)deque(['B', 'D', 'A', '1', '2', '3', '2', 'a', 'b'])>>> d.remove('2') # 移除查找到的第一个元素 '2'>>> print(d)deque(['B', 'D', 'A', '1', '3', '2', 'a', 'b'])>>> d.reverse() # 逆序排列>>> print(d)deque(['b', 'a', '2', '3', '1', 'A', 'D', 'B'])>>> d.rotate(2) # 向右循环 2 步>>> print(d)deque(['D', 'B', 'b', 'a', '2', '3', '1', 'A'])>>> d.rotate(-2) # 向左循环 2 步>>> print(d)deque(['b', 'a', '2', '3', '1', 'A', 'D', 'B']) 3、collections.defaultdict()使用字典（dict）时，如果引用的 key 不存在，就会抛出 KeyError，如果希望 key 不存在时，返回一个默认值，就可以用 defaultdict() 方法来为字典提供默认值。
该方法返回一个新的类似字典的对象，defaultdict 是内置 dict 类的子类，它重载了一个方法并添加了一个可写的实例变量，其余的功能与 dict 类相同。
参数是一个函数，当没有参数调用时返回默认值。如果没有传递任何内容，则默认为None。
基本语法：collections.defaultdict([default_factory[, ...]])
应用举例：
>>> d = collections.defaultdict()>>> ddefaultdict(None, {})>>> e = collections.defaultdict(str)>>> edefaultdict(<class 'str'>, {}) >>> from collections import defaultdict>>> d = defaultdict(lambda: 'N/A')>>> d['key1'] = 'abc'>>> d['key1'] # key1 存在'abc'>>> d['key2'] # key2 不存在，返回默认值'N/A' >>> d = collections.defaultdict(str)>>> ddefaultdict(<class 'str'>, {})>>> d['python']''>>> ddefaultdict(<class 'str'>, {'python': ''})>>> d = {} # 普通字典调用不存在的键时，将会抛异常>>> d['python']Traceback (most recent call last):File "<pyshell#68>", line 1, in <module>d['python']KeyError: 'python'defaultdict 的一个典型用法是使用其中一种内置类型（如str、int、list或dict）作为默认参数（default_factory），因为这些内置类型在没有参数调用时返回空类型。
使用 list 作为 default_factory 的例子，可以很轻松地将（键-值对组成的）序列转换为（键-列表组成的）字典：
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]>>> d = collections.defaultdict(list)>>> for i, j in s:d[i].append(j)>>> print(d)defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})>>> print(sorted(d.items()))[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])] 4、collections.OrderedDict()使用字典（dict）时，key 是无序的。在对字典做迭代时，无法确定 key 的顺序，而 OrderedDict 方法返回一个 dict 子类的实例，保留了添加顺序的字典对象，它具有专门用于重新排列字典顺序的方法。如果在已经存在的 key 上添加新的值，将会保留原来的 key 的位置，覆盖 value 值。
基本语法：collections.OrderedDict([items])
应用举例：
>>> import collections>>> d = collections.OrderedDict()>>> d['key1'] = 'value1'>>> d['key2'] = 'value2'>>> d['key3'] = 'value3'>>> d['key4'] = 'value4'>>> dOrderedDict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'), ('key4', 'value4')]) 5、collections.ChainMap()基本语法：collections.ChainMap(*maps)
一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。 如果没有 maps 被指定，就提供一个默认的空字典，这样一个新链至少有一个映射。
ChainMap 本身也是一个字典，但是查找的时候，会按照顺序在内部的字典依次查找。
应用举例：
>>> import collections>>> dict1 = {'A':1, 'B':2, 'C':3}>>> dict2 = {'D':4, 'E':5, 'F':6}>>> dict3 = collections.ChainMap(dict1, dict2)>>> dict3ChainMap({'A': 1, 'B': 2, 'C': 3}, {'D': 4, 'E': 5, 'F': 6}) >>> import collections>>> dict1 = {'A':1, 'B':2}>>> dict2 = {'A':3, 'C':4}>>> dict3 = collections.ChainMap(dict1, dict2)>>> print(dict3)ChainMap({'A': 1, 'B': 2}, {'A': 3, 'C': 4})>>> print(dict3['A']) # 搜索从左到右，先到先得1ChainMap 除了支持所有常用字典方法以外，还有以下三个方法：
① maps：一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，可以被修改。列表最少包含一个映射。
② new_child(m=None)：返回一个新的 ChainMap 类，包含了一个新映射(map)，后面跟随当前实例的全部映射(map)。如果 m 被指定，它就成为不同新的实例，就是在所有映射前加上 m，如果没有指定，就加上一个空字典，这样的话一个 d.new_child() 调用等价于 ChainMap({}, *d.maps)，这个方法用于创建子上下文，不改变任何父映射的值。
③ parents：属性返回一个新的 ChainMap 包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。 使用的场景类似在 nested scopes 嵌套作用域中使用 nonlocal 关键词。用例也可以类比内建函数 super() 。一个 d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。
应用举例：
import collectionsdict1 = {'A':1, 'B':2}dict2 = {'中文':3, '英文':4}dict3 = {'C':'10', 'D':'20'}dict4 = collections.ChainMap(dict1, dict2, dict3)dict5 = dict4.new_child()dict6 = dict4.new_child(m = dict2)print('dict4 = ', dict4)print('dict5 = ', dict5)print('dict6 = ', dict6)print('dict5.parents = ', dict5.parents)print('dict6.parents = ', dict6.parents)输出结果：
dict4 = ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})dict5 = ChainMap({}, {'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})dict6 = ChainMap({'中文': 3, '英文': 4}, {'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})dict5.parents = ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})dict6.parents = ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'}) 6、collections.Counter()一个 Counter 是一个 dict 的子类，用于计数可哈希对象。它是一个集合，元素像字典键（key）一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数。 Counter 类有点像其他语言中的 bags 或 multisets，另外，Counter 还支持算术和集合操作。简单来说，Counter 主要就是用来对访问的对象的频率进行计数。
基本语法：collections.Counter([iterable-or-mapping])
应用举例：
# 统计字符出现的次数>>> import collections>>> print(collections.Counter('hello world'))Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})# 统计单词数>>> import collections>>> print(collections.Counter('hello world i love python hello python'.split()))Counter({'hello': 2, 'python': 2, 'world': 1, 'i': 1, 'love': 1})# 获取指定对象的访问次数，也可以使用get()方法>>> import collections>>> c = collections.Counter('hello world i love python hello python'.split())>>> print(c['python'])2常用的有以下四种方法：
① elements()：返回一个迭代器，其中每个元素将重复出现计数值所指定次，如果一个元素的计数小于1，就会被忽略。
>>> import collections>>> c = collections.Counter(a=4, b=2, c=0, d=-2)>>> print(c.elements())<itertools.chain object at 0x000001940EF57C18>>>> print(sorted(c.elements()))['a', 'a', 'a', 'a', 'b', 'b']② most_common([n])：返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。 如果 n 被省略或为 None，将返回计数器中的所有元素，计数值相等的元素按首次出现的顺序排序。
>>> import collections>>> c = collections.Counter('abracadabra')>>> print(c.most_common(3))[('a', 5), ('b', 2), ('r', 2)]>>> print(c.most_common())[('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]③ subtract([iterable-or-mapping])：从迭代对象或映射对象中减去元素。类似于 dict.update()，但是是减去，而不是替换，输入和输出都可以是0或者负数。
>>> import collections>>> c = collections.Counter(a=4, b=2, c=0, d=-2)>>> d = collections.Counter(a=1, b=2, c=3, d=4)>>> c.subtract(d)>>> cCounter({'a': 3, 'b': 0, 'c': -3, 'd': -6})④ update([iterable-or-mapping])：从迭代对象计数元素或者从另一个映射对象 (或计数器) 添加。 类似于 dict.update() 但是是加上，而不是替换，另外，迭代对象应该是序列元素，而不是一个键值对。
>>> import collections>>> c = collections.Counter('which')>>> d = collections.Counter('witch')>>> c.update(d)>>> cCounter({'h': 3, 'w': 2, 'i': 2, 'c': 2, 't': 1})
