歡迎加入 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()
該函數主要功能是：命名元組賦予每個位置一個含義，提供可讀性和自文檔性。
基本語法：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.y
2
>>> 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() | 移除所有元素，使其長度爲 0 |
| copy() | 創建一份淺拷貝 |
| count(x) | 計算 deque 中元素等於 x 的個數 |
| extend(iterable) | 添加 iterable 參數中的所有元素到最右端 |
| extendleft(iterable) | 添加 iterable 參數中的所有元素到最左端 注意，左添加時，結果中 iterable 參數中的順序將被反過來添加 |
| index(x[, start[, stop]]) | 返回 x 在 deque 中的位置（在索引 start 之後，索引 stop 之前） 返回第一個匹配項，如果未找到則引發 ValueError |
| insert(i, x) | 在位置 i 插入 x，如果插入會導致一個限長 deque 超出長度 maxlen 的話，就引發 IndexError |
| pop() | 移去 deque 最右邊的元素並返回該元素，若沒有該元素，則引發 IndexError 索引錯誤 |
| popleft() | 移去 deque 最左邊的元素並返回該元素，若沒有該元素，則引發 IndexError 索引錯誤 |
| remove(value) | 移去找到的第一個 value，若沒有該元素，則引發 ValueError |
| reverse() | 將 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()
>>> d
defaultdict(None, {})
>>> e = collections.defaultdict(str)
>>> e
defaultdict(<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)
>>> d
defaultdict(<class 'str'>, {})
>>> d['python']
''
>>> d
defaultdict(<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'
>>> d
OrderedDict([('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)
>>> dict3
ChainMap({'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']) # 搜索從左到右，先到先得
1
ChainMap 除了支持所有常用字典方法以外，還有以下三個方法：
① 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 collections
dict1 = {'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)
>>> c
Counter({'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)
>>> c
Counter({'h': 3, 'w': 2, 'i': 2, 'c': 2, 't': 1})