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