collections集合模塊 [namedtuple,deque,*]

collections是Python內建的一個集合模塊，提供了許多有用的集合類。

namedtuple

namedtuple是一個函數, 它用來建立一個自定義的tuple對象,而且規定了 tuple元素的個數, 並能夠用屬性而不是索引來引用tuple的某個元素,

這樣一來，咱們用namedtuple能夠很方便地定義一種數據類型，它具有tuple的不變性，又能夠根據屬性來引用，使用十分方便。

能夠驗證建立的Point對象是tuple的一種子類：

from collections import namedtuple
'''

'''
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
>>> p.x
1
>>> p.y
2

檢測是否爲tuple類型

>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True

相似的，若是要用座標和半徑表示一個圓，也能夠用namedtuple定義：

# namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用List存儲數據時,按索引訪問元素很快,可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除就很慢了。

deque是爲了高效的實現插入和刪除操做的雙向列表，適用於隊列和棧：

 

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

 

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。

使用 deque(maxlen=N) 構造函數會新建一個固定大小的隊列。當新的元素加入而且這個隊列已滿的時候， 最老的元素會自動被移除掉。

In [20]: q.append(1)

In [21]: q.append(1)

In [22]: q.append(1)

In [23]: q.append(2)

In [24]: q.append(3)

In [25]: q
Out[25]: deque([1, 2, 3])

In [26]: q.append(4)

In [27]: q
Out[27]: deque([2, 3, 4])

In [28]: q.append(5)

In [29]: q
Out[29]: deque([3, 4, 5])

若是你不設置隊列的大小,那麼就會獲得一個無限大小隊列，你能夠在隊列兩端執行添加和彈出元素的操做

在隊列兩端插入或刪除元素時間複雜度都是 O(1) ，而在列表的開頭插入或刪除元素的時間複雜度爲 O(N) 。

from collections import deque


def search(lines, pattern, history=5):
    previous_lines = deque(maxlen=history)
    for li in lines:
        if pattern in li:
            yield li, previous_lines
        previous_lines.append(li)

# Example use on a file
if __name__ == '__main__':
    with open(r'../../cookbook/somefile.txt') as f:
        for line, prevlines in search(f, 'python', 5):
            for pline in prevlines:
                print(pline, end='')
            print(line, end='')
            print('-' * 20)

返回匹配的最後N行

 

defaultdict

使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默認值
'N/A'

注意默認值是調用函數返回的，而函數在建立defaultdict對象時傳入。

除了在Key不存在時返回默認值，defaultdict的其餘行爲跟dict是徹底同樣的。

 

OrderedDict 

使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。

若是要保持Key的順序，能夠用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是無序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key會按照插入的順序排列，不是Key自己排序：

In [1]: from collections import OrderedDict

In [2]: od = OrderedDict()

In [3]: od['x'] = 1

In [4]: od['z'] = 0

In [5]: od['q'] = 3

In [7]: od

Out[7]: OrderedDict([('x', 1), ('z', 0), ('q', 3)])

Counter

Counter是一個簡單的計數器，例如，統計字符出現的個數：

In [8]: from collections import Counter

In [9]: c=Counter()

In [10]: for ch in '21212132131298475984758712368271':
    ...:     c[ch] = c[ch] + 1
    ...:     

In [11]: c
Out[11]: 
Counter({'1': 7,
         '2': 7,
         '3': 3,
         '4': 2,
         '5': 2,
         '6': 1,
         '7': 4,
         '8': 4,
         '9': 2})