collections模組

作者:Shawn
Python3.7
文件：
https://docs.python.org/3/library/collections.html

• python中的collections模組中有一些特殊的容器型別，有事會很方便。

• collections模組
  • deque：長度固定的雙向佇列
  • Counter：計數器
  • defaultdict：不會因為鍵值不存在而報錯
  • OrderDict：有序的dict
  • namedtuple：構建有名字的元組和有名字的類
  • ChainMap：容納多個對映物件的容器
  • User系列：可自定義的傳統容器

deque：長度固定的雙向佇列

collections.deque([iterable[, maxlen]])

• deque(maxlen=N)建立一個長度為N的固定佇列的雙向佇列。
• 佇列滿時在此端新增n個值會同時刪除彼端的n個值。

>>> from collections import deque
>>> q = deque(range(5), maxlen=5)
>>> 
 
q
deque([0, 1, 2, 3, 4], maxlen=5)
>>> q.append(5)
>>> q
deque([1, 2, 3, 4, 5], maxlen=5)
>>> q.rotate(3)
>>> q
deque([3, 4, 5, 1, 2], maxlen=5)
>>> q.appendleft(-1)
>>> q
deque([-1, 3, 4, 5, 1], maxlen=5)
>>> q.extendleft([11,22,33])
>>> 
 
q
deque([33, 22, 11, -1, 3], maxlen=5)

• maxlen一經設定不能修改。
• rotate(m)：正值時右側m個元素移至左側，負值相反。
• len(d)=d.maxlen時，開始達到上限，增加會導致另一側的刪除。
• extendleft()把其中的元素逐個相加到左側。

Counter：計數器

collections.Counter([iterable-or-mapping])

• 以鍵值對的形式儲存，元素為key，計數為value。

• 建立

>>> c = Counter()  
># 建立一個空的Counter類
>
>>> c = Counter('gallahad')  
># 從一個可iterable物件（list、tuple、dict、字串等）建立
>
>>> c = Counter({'a': 4, 'b': 2})  
># 從一個字典物件建立
>
>>> c = Counter(a=4, b=2)  
># 從一組鍵值對建立

• 訪問
  
  • 存在則返回計數，不存在返回0

>>> c = Counter("abcdefgab")
>>> c["a"]
2
>>> c["c"]
1
>>> c["h"]
0

• 計數器的更新
• update()進行增加更新

>>> c = Counter('which')
>>> c.update('witch')  # 使用另一個iterable物件更新
>>> c['h']
3
>>> d = Counter('watch')
>>> c.update(d)  # 使用另一個Counter物件更新
>>> c['h']
4

• subtract()進行減少更新

>>> c = Counter('which')
>>> c.subtract('witch')  # 使用另一個iterable物件更新
>>> c['h']
1
>>> d = Counter('watch')
>>> c.subtract(d)  # 使用另一個Counter物件更新
>>> c['a']
-1

• 計數為0不一定表示元素不存在。

• 刪除元素

  • 用del Counter[key]對元素進行刪除

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> c["b"] = 0
>>> c
Counter({'a': 2, 'c': 2, 'd': 1, 'b': 0})
>>> del c["a"]
>>> c
Counter({'c': 2, 'b': 2, 'd': 1})

• element()
  
  • 按value返回key，value小於1的key不返回。

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

• most_common([n])
  
  • 返回top n個元素的列表，沒有n則預設全部元素

>>> c = Counter('abracadabra')
>>> c.most_common()
[('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]
>>> c.most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

• 算術和集合操作
  
  • +-&|也可用於Counter操作

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d  # c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d  # subtract（只保留正數計數的元素）
Counter({'a': 2})
>>> c & d  # 交集:  min(c[x], d[x])
Counter({'a': 1, 'b': 1})
>>> c | d  # 並集:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

• 常用操作
  
  • 來源於官方文件

sum(c.values()) 
#所有計數的總數

c.clear() 
#重置Counter物件，注意不是刪除

list(c) 
#將c中的鍵轉為列表

set(c) 
#將c中的鍵轉為set

dict(c) 
#將c中的鍵值對轉為字典

c.items() 
#轉為(elem, cnt)格式的列表

Counter(dict(list_of_pairs)) 
#從(elem, cnt)格式的列表轉換為Counter類物件

c.most_common()[:-n:-1] 
#取出計數最少的n-1個元素

c += Counter() 
#移除0和負值

defaultdict：不會因為鍵值不存在而報錯

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

• dict中，若訪問的key不存在，則KeyError。
• 用defaultdict則會返回一個預設值。

>>> from collections import defaultdict
>>> d = defaultdict(list)
>>> d['a']
[]
>>> d['a'].append(1)
>>> d
defaultdict(<class 'list'>, {'a': [1]})
>>> d['a'].append(2)
>>> d['b'].append(4)
>>> d
defaultdict(<class 'list'>, {'a': [1, 2], 'b': [4]})
>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
     d[k] += 1
>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

OrderDict：有序的dict

collections.OrderedDict([items])

• OrderDict的key會嚴格按照新增順序保持。

>>> from collections import OrderedDict
>>> d = OrderedDict()
>>> d
OrderedDict()
>>> d['foo'] = 1
>>> d['bar'] = 2
>>> d['spam'] = 3
>>> d['grok'] = 4
>>> for key in d:
...     print(key, d[key])
...
foo 1
bar 2
spam 3
grok 4

namedtuple：構建有名字的元組和有名字的類

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

• 建立一個具名元組需要兩個引數，一個是類名，另一個是類的各個欄位的名字。後者可以是由數個字串組成的可迭代物件，或者是由空格分隔開的欄位名組成的字串。

>>> from collections import namedtuple
>>> City = namedtuple('City', 'name country population coordinates')
>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
>>> tokyo
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722,
139.691667))
>>> tokyo.population
36.933
>>> tokyo.coordinates
(35.689722, 139.691667)
>>> tokyo[1]
'JP'

ChainMap：容納多個對映物件的容器

collections.ChainMap(*maps)

• 進行鍵查詢操作的時候，這些物件會被當作一個整體被逐個查詢，直到鍵被找到為止。
• ChainMap只是簡單的維護一個記錄底層對映關係的列表，然後重新定義常見的字典操作來掃描這個列表。大部分的操作都可以正常的工作。
• 如果與重複的鍵，那麼這裡會採用第一個對映中所對應的鍵值。
• 修改對映的操作總會作用在列出的第一個對映結構上。
• 注：ChainMap使用的是原始的字典，也就是說如果任一個原始的字典發生了變化，那麼合併之後的字典也將會發生變化。但字典的update方法則不會變化。

>>> from collections import ChainMap
>>> a = {'x': 1, 'y': 2}
>>> b = {'y': 3 , 'z': 4}
>>> c = ChainMap(a, b)
>>> c
ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})
>>> len(c)
3
>>> c.keys()
KeysView(ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4}))
>>> c.values()
ValuesView(ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4}))
>>> c['x']
1
>>> c['y']
2
>>> c['y'] = 22
>>> c['z'] = 9
>>> del c['x']
>>> a
{'y': 22, 'z': 9}
>>> c
ChainMap({'y': 22, 'z': 9}, {'y': 3, 'z': 4})
>>> a['a'] = 4
>>> a
{'y': 22, 'z': 9, 'a': 4}
>>> c
ChainMap({'y': 22, 'z': 9, 'a': 4}, {'y': 3, 'z': 4})

User系列：可自定義的傳統容器

collections.UserDict([initialdata])
collections.UserList([list])
collections.UserString(seq)

• 這三個容器皆是對傳統容器的封裝（字典、列表、字串），當需要編寫功能與這些容器相近的容器時，可以通過對這三者的繼承、覆寫相應的方法來快速實現。