歡迎加入 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.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 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) >>> 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})

總結

以上是生活随笔為你收集整理的【Python 标准库学习】容器数据类型库 — collections的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。