技術文章 » Python-collections模組

Python-collections模組

2020-10-01 11:00:16

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

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

使用 set 作為 default_factory

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

OrderedDict

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

collections.OrderedDict 類提供了保留他們新增順序的字典物件

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

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

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

namedtuple

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

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

範例化命名元組

>>> 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

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

>>> 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

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

>>> 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 是去掉了列表開頭的元素

>>> 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({})