Python的collections模塊真的很好用

Posted on 2021-03-01 by WalkonNet

collections是實現瞭特定目標的容器，以提供Python標準內建容器 dict , list , set , 和 tuple 的替代選擇。為瞭讓大傢更好的認識，本文詳細總結collections的相關知識，一起來學習吧！

collections模塊：實現瞭特定目標的容器，以提供Python標準內建容器 dict、list、set、tuple 的替代選擇。

Counter：字典的子類，提供瞭可哈希對象的計數功能。

defaultdict：字典的子類，提供瞭一個工廠函數，為字典查詢提供瞭默認值。

OrderedDict：字典的子類，保留瞭他們被添加的順序。

namedtuple：創建命名元組子類的工廠函數。

deque：類似列表容器，實現瞭在兩端快速添加(append)和彈出(pop)。

ChainMap：類似字典的容器類，將多個映射集合到一個視圖裡面。

Counter

Counter是一個dict子類，主要是用來對你訪問的對象的頻率進行計數。

>>> import collections
>>> # 統計字符出現的次數
... collections.Counter('hello world')
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
>>> # 統計單詞個數
... collections.Counter('hello world hello lucy'.split())
Counter({'hello': 2, 'world': 1, 'lucy': 1})

常用方法：

elements()：返回一個迭代器，每個元素重復計算的個數，如果一個元素的計數小於1,就會被忽略。

most_common([n])：返回一個列表，提供n個訪問頻率最高的元素和計數

subtract([iterable-or-mapping])：從迭代對象中減去元素，輸入輸出可以是0或者負數

update([iterable-or-mapping])：從迭代對象計數元素或者從另一個映射對象 (或計數器) 添加。

>>> c = collections.Counter('hello world hello lucy'.split())
>>> c
Counter({'hello': 2, 'world': 1, 'lucy': 1})
>>> # 獲取指定對象的訪問次數，也可以使用get方法
... c['hello']
2
>>> # 查看元素
... list(c.elements())
['hello', 'hello', 'world', 'lucy']
>>> c1 = collections.Counter('hello world'.split())
>>> c2 = collections.Counter('hello lucy'.split())
>>> c1
Counter({'hello': 1, 'world': 1})
>>> c2
Counter({'hello': 1, 'lucy': 1})
>>> # 追加對象，+或者c1.update(c2)
... c1+c2
Counter({'hello': 2, 'world': 1, 'lucy': 1})
>>> # 減少對象，-或者c1.subtract(c2)
... c1-c2
Counter({'world': 1})
>>> # 清除
... c.clear()
>>> c
Counter()

defaultdict

返回一個新的類似字典的對象。defaultdict 是內置 dict 類的子類。

class collections.defaultdict([default_factory[, ...]])

>>> d = collections.defaultdict()
>>> d
defaultdict(None, {})
>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {})

例子

defaultdict的一個典型用法是使用其中一種內置類型（如str、int、list或dict等）作為默認工廠，這些內置類型在沒有參數調用時返回空類型。

>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {})
>>> e['hello']
''
>>> e
defaultdict(<class 'str'>, {'hello': ''})
>>> # 普通字典調用不存在的鍵時，報錯
... e1 = {}
>>> e1['hello']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'hello'

使用 int 作為 default_factory

>>> fruit = collections.defaultdict(int)
>>> fruit['apple'] = 2
>>> fruit
defaultdict(<class 'int'>, {'apple': 2})
>>> fruit['banana'] # 沒有對象時，返回0
0
>>> fruit
defaultdict(<class 'int'>, {'apple': 2, 'banana': 0})

使用 list 作為 default_factory

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = collections.defaultdict(list)
>>> for k,v in s:
...   d[k].append(v)
...
>>> d
defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
>>> d.items()
dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

使用 dict 作為 default_factory

```python
>>> nums = collections.defaultdict(dict)
>>> nums[1] = {'one':1}
>>> nums
defaultdict(, {1: {'one': 1}})
>>> nums[2]
{}
>>> nums
defaultdict(, {1: {'one': 1}, 2: {}})

使用 set 作為 default_factory

```python
>>> types = collections.defaultdict(set)
>>> types['手機'].add('華為')
>>> types['手機'].add('小米')
>>> types['顯示器'].add('AOC')
>>> types
defaultdict(<class 'set'>, {'手機': {'華為', '小米'}, '顯示器': {'AOC'}})

## OrderedDict

Python字典中的鍵的順序是任意的，它們不受添加的順序的控制。

collections.OrderedDict 類提供瞭保留他們添加順序的字典對象。

```python
>>> o = collections.OrderedDict()
>>> o['k1'] = 'v1'
>>> o['k3'] = 'v3'
>>> o['k2'] = 'v2'
>>> o
OrderedDict([('k1', 'v1'), ('k3', 'v3'), ('k2', 'v2')])

如果在已經存在的 key 上添加新的值，將會保留原來的 key 的位置，然後覆蓋 value 值。

```python
>>> o['k1'] = 666
>>> o
OrderedDict([('k1', 666), ('k3', 'v3'), ('k2', 'v2')])
>>> dict(o)
{'k1': 666, 'k3': 'v3', 'k2': 'v2'}

## namedtuple

三種定義命名元組的方法：第一個參數是命名元組的構造器（如下的：Person1，Person2，Person3）

```python
>>> P1 = collections.namedtuple('Person1',['name','age','height'])
>>> P2 = collections.namedtuple('Person2','name,age,height')
>>> P3 = collections.namedtuple('Person3','name age height')

實例化命名元組

```python
>>> lucy = P1('lucy',23,180)
>>> lucy
Person1(name='lucy', age=23, height=180)
>>> jack = P2('jack',20,190)
>>> jack
Person2(name='jack', age=20, height=190)
>>> lucy.name # 直接通過 實例名.屬性 來調用
'lucy'
>>> lucy.age
23

deque

collections.deque 返回一個新的雙向隊列對象，從左到右初始化（用方法 append()），從 iterable（迭代對象）數據創建。如果 iterable 沒有指定，新隊列為空。

collections.deque 隊列支持線程安全，對於從兩端添加（append）或者彈出（pop），復雜度O(1)。

雖然 list 對象也支持類似操作，但是這裡優化瞭定長操作（pop(0)、insert(0,v)）的開銷。

如果 maxlen 沒有指定或者是 None ，deque 可以增長到任意長度。否則，deque 就限定到指定最大長度。一旦限定長度的 deque 滿瞭，當新項加入時，同樣數量的項就從另一端彈出。

支持的方法：

append(x)：添加x到右端。

appendleft(x)：添加x到左端。

clear()：清除所有元素，長度變為0。

copy()：創建一份淺拷貝。

count(x)：計算隊列中個數等於x的元素。

extend(iterable)：在隊列右側添加iterable中的元素。

extendleft(iterable)：在隊列左側添加iterable中的元素，註：在左側添加時，iterable參數的順序將會反過來添加。

index(x[,start[,stop]])：返回第 x 個元素（從 start 開始計算，在 stop 之前）。返回第一個匹配，如果沒找到的話，拋出 ValueError 。

insert(i,x)：在位置 i 插入 x 。註：如果插入會導致一個限長deque超出長度 maxlen 的話，就拋出一個 IndexError 。

pop()：移除最右側的元素。

popleft()：移除最左側的元素。

remove(value)：移去找到的第一個 value。沒有拋出ValueError。

reverse()：將deque逆序排列。返回 None 。

maxlen：隊列的最大長度，沒有限定則為None。

>>> d = collections.deque(maxlen=10)
>>> d
deque([], maxlen=10)
>>> d.extend('python')
>>> [i.upper() for i in d]
['P', 'Y', 'T', 'H', 'O', 'N']
>>> d.append('e')
>>> d.appendleft('f')
>>> d.appendleft('g')
>>> d.appendleft('h')
>>> d
deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'e'], maxlen=10)
>>> d.appendleft('i')
>>> d
deque(['i', 'h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n'], maxlen=10)
>>> d.append('m')
>>> d
deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'm'], maxlen=10)

## ChainMap

問題背景是我們有多個字典或者映射，想把它們合並成為一個單獨的映射，有人說可以用update進行合並，這樣做的問題就是新建瞭一個數據結構以致於當我們對原來的字典進行更改的時候不會同步。如果想建立一個同步的查詢方法，可以使用 ChainMap。

可以用來合並兩個或者更多個字典，當查詢的時候，從前往後依次查詢。簡單使用：

```python
>>> d1 = {'apple':1,'banana':2}
>>> d2 = {'orange':2,'apple':3,'pike':1}
>>> combined1 = collections.ChainMap(d1,d2)
>>> combined2 = collections.ChainMap(d2,d1)
>>> combined1
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> combined2
ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})
>>> for k,v in combined1.items():
...   print(k,v)
...
orange 2
apple 1
pike 1
banana 2
>>> for k,v in combined2.items():
...   print(k,v)
...
apple 3
banana 2
orange 2
pike 1
</code></pre>

有一個註意點就是當對ChainMap進行修改的時候總是隻會對第一個字典進行修改，如果第一個字典不存在該鍵，會添加。

<pre><code class="language-python line-numbers">>>> d1 = {'apple':1,'banana':2}
>>> d2 = {'orange':2,'apple':3,'pike':1}
>>> c = collections.ChainMap(d1,d2)
>>> c
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> c['apple']
1
>>> c['apple'] = 2
>>> c
ChainMap({'apple': 2, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> c['pike']
1
>>> c['pike'] = 3
>>> c
ChainMap({'apple': 2, 'banana': 2, 'pike': 3}, {'orange': 2, 'apple': 3, 'pike': 1})

從原理上面講，ChainMap 實際上是把放入的字典存儲在一個隊列中，當進行字典的增加刪除等操作隻會在第一個字典上進行，當進行查找的時候會依次查找，new_child() 方法實質上是在列表的第一個元素前放入一個字典，默認是{}，而 parents 是去掉瞭列表開頭的元素。

```python
>>> a = collections.ChainMap()
>>> a['x'] = 1
>>> a
ChainMap({'x': 1})
>>> b = a.new_child()
>>> b
ChainMap({}, {'x': 1})
>>> b['x'] = 2
>>> b
ChainMap({'x': 2}, {'x': 1})
>>> b['y'] = 3
>>> b
ChainMap({'x': 2, 'y': 3}, {'x': 1})
>>> a
ChainMap({'x': 1})
>>> c = a.new_child()
>>> c
ChainMap({}, {'x': 1})
>>> c['x'] = 1
>>> c['y'] = 1
>>> c
ChainMap({'x': 1, 'y': 1}, {'x': 1})
>>> d = c.parents
>>> d
ChainMap({'x': 1})
>>> d is a
False
>>> d == a
True

>>> a = {'x':1,'z':3}
>>> b = {'y':2,'z':4}
>>> c = collections.ChainMap(a,b)
>>> c
ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
>>> c.maps
[{'x': 1, 'z': 3}, {'y': 2, 'z': 4}]
>>> c.parents
ChainMap({'y': 2, 'z': 4})
>>> c.parents.maps
[{'y': 2, 'z': 4}]
>>> c.parents.parents
ChainMap({})
>>> c.parents.parents.parents
ChainMap({})

到此這篇關於Python的collections模塊真的很好用的文章就介紹到這瞭,更多相關Python的collections模塊內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

Python的collections模塊真的很好用

deque

推薦閱讀：

發佈留言取消回覆

近期文章

deque

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆