Python collection模块

​ collections模块主要实现了一些container datatypes（容器类型），作为builtin容器类型dict、list、set和tuple等的一个补充，包括以下新定义的容器类型：

类型	用途
namedtuple()	factory function for creating tuple subclasses with named fields
deque	双端队列，支持两端快速出入队列操作
ChainMap	将多个mapping 对象组合成一个mapping对象
Counter	dict subclass，用来计数hashable对象
OrderedDict	dict subclass that remembers the order entries were added
defaultdict	dict subclass，对dict中missing的key，调用一个指定的factory function
UserDict	wrapper around dictionary objects for easier dict subclassing
UserList	wrapper around list objects for easier list subclassing
UserString	wrapper around string objects for easier string subclassing

chainMap

​ chainMap(*maps)用于连接多个mapping对象称为一个mapping，通常其速度快于使用字典的update方法连接。其构造方法为collections.ChainMap(*maps)，当不传入参数时，ChainMap则会产生一个空dict；ChainMap底层用list存储mapping对象，并且可以通过.maps属性对mapping对象进行修改，对mapping对象的修改能够即时反应到ChainMap对象；查找会依次搜索每一个mapping对象，而修改、删除、新增只会在第一个mapping对象上进行操作。

​ ChainMap对象除了支持所有的mapping对象方法，还有以下几个特有的属性、方法：

• maps

  如上所述，返回ChainMap所包装的mapping对象所组成的list，该list至少包含一个mapping对象；

• new_child(m=None)

  创建child context，等价于ChainMap(m, *d.maps)，当m为None时，等价于ChainMap({}, *d.maps)

• parents

  返回parent context，即返回除了第一个mapping对象之外的所有mapping对象组成的ChainMap对象

  举个简单的例子：

  >>> baseline = {'music': 'bach', 'art': 'rembrandt'}                                                                
  >>> adjustments = {'art': 'van gogh', 'opera': 'carmen'}                                                            
  >>> from collections import ChainMap                                                                                
  >>> a = ChainMap(adjustments, baseline) 
  >>> a['art']                                                                                                        
  'van gogh'
  

Counter

​ Counter([iterable-or-mapping])类用于快速、方便的计数，使用频率很高的一个功能，它继承于dict，用于计数可哈希的对象，计数的数值可以是正整数、负整数和零，实例化方法有以下几种：

>>> c = Counter()                           # a new, empty counter
>>> c = Counter('gallahad')                 # a new counter from an iterable
>>> c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
>>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args

​ Counter和dict不同之处在于如果Counter检索一个不存在的key时不会抛出KeyError，而是返回0：

>>> c = Counter(['eggs', 'ham'])
>>> c['bacon']                              # count of a missing element is zero
0
>>> del c['eggs']

​ 除了支持父类dict大部分的方法（不支持fromkeys(iterable)以及update([*iterable-or-mapping*])略有不同），还包括以下几个：

• elements()

  返回一个iterator对象，每个元素重复其计数数值的次数（如果计数数值小于1，就忽略它）

  >>> c = Counter(a=4, b=2, c=-1, d=-2)
  >>> c.elements()
  >>> list(c.elements())  # If an element’s count is less than one, elements() will ignore it.
  
  <itertools.chain at 0x112f1be10>
  ['a', 'a', 'a', 'a', 'b', 'b']
  

• most_common(n)

  返回计数最大的n个元素

  >>> c.most_common(2)
  c.most_common(2)
  
  >>> c.most_common()[:-3:-1] # c.most_common()[:-n-1:-1] n least common elements
  

• subtract()

  执行计数减法操作，加法可以使用update()方法

  >>> c.subtract(Counter(a=1, b=2, c=3, d=4))
  >>> c
  >>> c.update({'a':3})  # update([iterable-or-mapping]), 添加式的update
  >>> c
  
  Counter({'a': 3, 'b': 0, 'c': -4, 'd': -6})
  Counter({'a': 6, 'b': 0, 'c': -4, 'd': -6})
  

  Counter还支持一些数学运算符，进行简便的运算：

  >>> c = Counter(a=-3, b=5, c=4)
  >>> d = Counter(a=-1, b=2, c=0)
  >>> c + d                       # add two counters together:  c[x] + d[x] (keeping only positive counts)
  Counter({'b': 7, 'c': 4})
  >>> c - d                       # subtract (keeping only positive counts)
  Counter({'b': 3, 'c': 4})
  >>> c & d                       # intersection:  min(c[x], d[x]) (keeping only positive counts)
  Counter({'b': 2})
  >>> c | d                       # union:  max(c[x], d[x]) (keeping only positive counts)
  Counter({'b': 5, 'c': 4})
  
  # 特殊的是，还提供两个shortcuts来表示空的Counter()加上或减去Counter对象
  >>> c = Counter(a=2, b=-4)
  >>> +c  # 相当于 Counter() + c
  Counter({'a': 2})
  >>> -c  # 相当于 Counter() - c
  Counter({'b': 4})
  

deque

​ collections.deque([iterable[, maxlen]])，以一个iterable对象作为参数进行初始化，得到一个双端队列。双端队列支持从任一侧线程安全，内存高效的append和pop操作，并且复杂度为时间O(1)。如果未指定maxlen或为None，则双端队列的长度可以增长到任意大小；反之，双端队列会限制为指定的最大长度。一旦限定长度的双端队列达到最大长度时，若再插入新的item，则队列另一端会自动丢弃相应数量的item。

• 方法和属性

  • append(x)、appendleft(x) 插入元素，前者插到队列右边，后者插入到左边
  • extend(iterable)、extendleft(iterable) 插入多个元素，前者插到队列右边，后者插入到左边
  • pop()、popleft() 去除并返回最左（右）边的元素
  • clear() 清空队列
  • copy() 队列浅拷贝（同copy.copy(d)），深拷贝使用copy.deepcopy(d)
  • count(x) 计数队列中与x大小相等的元素个数
  • index(x[, start[, stop]]) 在[start, stop)范围内查找与x相等的第一个元素的index，如果没找到抛出ValueErrorc错误
  • insert(i, x) 在位置i插入x，若i位置超出队列指定的最大长度，引发IndexError
  • remove(value) 去除第一个与value相等的元素，若不存在引发ValueError
  • reverse() in place的反转队列元素
  • rotate(n=1) n> 0, 队列向右移n步，反之向左移
  • maxlen,这是一个只读属性

  除了以上的属性方法, deques 还支持iteration, pickling, len(d), reversed(d), copy.copy(d), copy.deepcopy(d), in 操作符 以及索引操作，如d[-1]. 索引队列两边的元素复杂度都是O(1)，当索引获取中间的元素复杂度会是O(n), 因此涉及大量中间元素索引操作的场景应该使用list。

• 应用举例

  比如获取一个文件的后N行可以采用以下方式：

  def tail(filename, n=10):
      with open(filename) as f:
          return deque(f, n)
  

defaultdict

​ 关于defaultdict，我们可以先看一下dict中一个类似功能的函数setdefault(k, d=None):

d = {}
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

for k, v in s:
    d.setdefault(k, []).append(v)

sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

​ 在上述代码中，setdefault(k, d=[])一句话相当于做了两件事情：一是获取key为k的的value，二是若该key不存在则设置其值为[]。即，d.get(k, [])以及如果key不存在就设置d[k] = []。现在再回到defaultdict，defaultdict([default_factory[, ...]])，构造方法中default_factory默认是None，defaultdict是dict的一个subclass，它重写了一个__miss__方法以及拥有一个default_factory属性。

• __miss__(key)

  • 该方法在当key不存在时才会且仅被__getitem__()调用，所以当使用dict.get()方法获取一个不存在的键值时，返回结果为None，而不是使用default_factory；

  • 当default_factory为None时，索引一个不存在的key会引发KeyError异常；

  • 当default_factory不为None时，索引一个不存在的key则使用default_factory进行初始化并返回值

    >>> from collections import defaultdict
    
    >>> d2 = defaultdict(int ,a=1, b=2)
    >>> d2['c']
    0
    
    >>> d2 = defaultdict(int ,a=1, b=2)
    >>> d2.get('c')
    None
    >>> d2
    defaultdict(int, {'a': 1, 'b': 2})
    
    >>> d1 = defaultdict(a=1, b=2)
    >>> d1['c']
    KeyError: 'c'
    

• default_factory

  该属性在上述__miss__()函数中使用，由构造函数中的default_factory初始化，默认为None

  ​ 因此，上述例子可以使用defaultdict来实现如下：

  s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
  d = defaultdict(list)
  for k, v in s:
      d[k].append(v)
  
  sorted(d.items())
  [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
  

namedtuple

​ namedtuple用来构造带字段名的元组。namedtuple的实例和普通元组消耗的内存一样多，因为字段名都被存在对应的类里面。这个类跟普通的对象实例比起来也要小一些，因为 Python 不会用 __dict__ 来存放这些实例的属性。它们可以在使用常规tuple的任何地方使用，并且它们还具有按名称（tuple只能按index）访问字段的能力。其构造函数为：collections.namedtuple(typename, field_names,*, rename=False, defaults=None, module=None)，简单例子如下：

>>> # Basic example
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
>>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
33
>>> x, y = p                # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y               # fields also accessible by name
33
>>> p                       # readable __repr__ with a name=value style
Point(x=11, y=22)

OrderedDict

​ OrderedDict和一般的dict类似，但是还具有记忆字典中存储的key的插入顺序。但是现在OrderDict可能用处不大了，因为从Python 3.7开始，一般的dict也具有这个特性。但是，dict和OrderedDict依旧有些区别：

• 对于常规dict，最重要的高效的mapping operations，而Track 插入顺序是次要的；
• 对于OrderedDict，最重要的是排序操作，而空间效率、迭代效率以及更新字典的性能是次要的；
• OrderedDict可以处理频繁的需要重排的操作，适合于Track最近的操作；
• 判断两个OrderedDict是否相等同时要求顺序也相同；
• OrderedDict的popitem(last=True)中可以通过last参数控制pop哪一端的元素；
• OrderedDict的move_to_end(key, last=True)可以高效的将元素移至末尾；
• 直到Python3.8，dict没有__reversed__()方法；

UserDict & UserList & UserString

​ UserDict & UserList & UserString分别是dict、list、str的一个wrapper，在实际应用中，已经很少使用到它们了，因为我们可以直接方便的继承它们，自定义对应的子类，稍微了解一下即可，下面给出一个简单的例子：