【Python 标准库学习】容器数据类型库 — collections

欢迎加入 Python 官方文档翻译团队：https://www.transifex.com/python-doc/

---

collections 模块实现了特定目标的容器，以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。

collections 模块官方文档：https://docs.python.org/3/library/collections.html

---

---

1、collections.namedtuple()

该函数主要功能是：命名元组赋予每个位置一个含义，提供可读性和自文档性。

基本语法：collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

typename：类名称，即通过 namedtuple 创建的一个元组的子类的类名

field_names：字段名称，结构类似于 [‘x’, ‘y’] 一样的字符串序列。也可以是一个纯字符串，用空白或逗号分隔开元素名，比如 ‘x y’ 或者 ‘x, y’，实际上类似于字典的 key，定义的元组可以通过这样的 key 去获取里面对应索引位置的元素值。

rename：如果 rename 指定为 True，那么 field_names 就不能包含非 Python 标识符、Python 中的关键字以及重复的 name，如果有，将会默认重命名为 ‘_index’ 的样式，index 表示该 name 在 field_names 中的索引，例：['abc', 'def', 'ghi', 'abc'] 将被转换成 ['abc', '_1', 'ghi', '_3']。

应用举例：

>>> import collections
>>> point = collections.namedtuple('point', ['x', 'y'])
>>> p = point(1, 2)          # 使用位置参数初始化namedtuple
>>> p.x                      # 使用对应字段名字获取namedtuple里面的元素
1
>>> p.y
2
>>> m = point(x=5, y=6)      # 使用关键字参数初始化namedtuple
>>> m[0]                     # 使用索引获取 namedtuple 里面的元素
5
>>> m[1]
6

2、collections.deque()

使用列表（list）存储数据时，按索引访问元素很快，但插入和删除元素却很慢，因为列表是线性存储，数据量大的时候，插入和删除效率很低，而 deque 恰好可以解决这个问题，实现了高效插入和删除操作。

deque 是双边队列（double-ended queue），具有队列和栈的性质，在列表的基础上增加了移动、旋转和增删等。

基本语法：collections.deque([iterable[, maxlen]])

deque 对象支持以下方法：

方法	功能
append(x)	添加 x 到最右端
appendleft(x)	添加 x 到最左端
clear()	移除所有元素，使其长度为 0
copy()	创建一份浅拷贝
count(x)	计算 deque 中元素等于 x 的个数
extend(iterable)	添加 iterable 参数中的所有元素到最右端
extendleft(iterable)	添加 iterable 参数中的所有元素到最左端 注意，左添加时，结果中 iterable 参数中的顺序将被反过来添加
index(x[, start[, stop]])	返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前） 返回第一个匹配项，如果未找到则引发 ValueError
insert(i, x)	在位置 i 插入 x，如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发 IndexError
pop()	移去 deque 最右边的元素并返回该元素，若没有该元素，则引发 IndexError 索引错误
popleft()	移去 deque 最左边的元素并返回该元素，若没有该元素，则引发 IndexError 索引错误
remove(value)	移去找到的第一个 value，若没有该元素，则引发 ValueError
reverse()	将 deque 逆序排列
rotate(n)	向右循环移动 n 步，如果 n 是负数，就向左循环 若 deque 不为空，向右循环移动一步等价于d.appendleft(d.pop()) 向左循环一步等价于d.append(d.popleft())

应用举例：

>>> import collections
>>> d = collections.deque(['a', 'b', 'c', 'd'])
>>> d.append('e')                                      # 添加一个元素 'e' 到最右端
>>> print(d)
deque(['a', 'b', 'c', 'd', 'e'])

>>> d.appendleft('f')                                  # 添加一个元素 'f' 到最左端
>>> print(d)
deque(['f', 'a', 'b', 'c', 'd', 'e'])

>>> d.clear()                                          # 移除所有元素
>>> print(d)
deque([])

>>> d = collections.deque(['1', '2', '3', '2'])
>>> print(d.count('2'))                                # 计算元素 '2' 的个数
2

>>> d.extend(['a', 'b', 'c'])                          # 添加一个列表的所有元素到最右端
>>> print(d)
deque(['1', '2', '3', '2', 'a', 'b', 'c'])

>>> d.extendleft(['A', 'B', 'C'])                      # 添加一个列表的所有元素到最左端
>>> print(d)
deque(['C', 'B', 'A', '1', '2', '3', '2', 'a', 'b', 'c'])

>>> print(d.index('2',0,5))                            # 在 0 - 5 索引范围内查找元素 '2' 的位置
4

>>> d.insert(2, 'D')                                   # 在索引值为 2 处插入元素 'D'
>>> print(d)
deque(['C', 'B', 'D', 'A', '1', '2', '3', '2', 'a', 'b', 'c'])

>>> d.pop()                                            # 移除最右边的元素并返回该元素
'c'
>>> print(d)
deque(['C', 'B', 'D', 'A', '1', '2', '3', '2', 'a', 'b'])

>>> d.popleft()                                        # 移除最左边的元素并返回该元素
'C'
>>> print(d)
deque(['B', 'D', 'A', '1', '2', '3', '2', 'a', 'b'])

>>> d.remove('2')                                      # 移除查找到的第一个元素 '2'
>>> print(d)
deque(['B', 'D', 'A', '1', '3', '2', 'a', 'b'])

>>> d.reverse()                                        # 逆序排列
>>> print(d)
deque(['b', 'a', '2', '3', '1', 'A', 'D', 'B'])

>>> d.rotate(2)                                        # 向右循环 2 步
>>> print(d)
deque(['D', 'B', 'b', 'a', '2', '3', '1', 'A'])

>>> d.rotate(-2)                                       # 向左循环 2 步
>>> print(d)
deque(['b', 'a', '2', '3', '1', 'A', 'D', 'B'])

3、collections.defaultdict()

使用字典（dict）时，如果引用的 key 不存在，就会抛出 KeyError，如果希望 key 不存在时，返回一个默认值，就可以用 defaultdict() 方法来为字典提供默认值。

该方法返回一个新的类似字典的对象，defaultdict 是内置 dict 类的子类，它重载了一个方法并添加了一个可写的实例变量，其余的功能与 dict 类相同。

参数是一个函数，当没有参数调用时返回默认值。如果没有传递任何内容，则默认为None。

基本语法：collections.defaultdict([default_factory[, ...]])

应用举例：

>>> d = collections.defaultdict()
>>> d
defaultdict(None, {})
>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {})

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

>>> d = collections.defaultdict(str)
>>> d
defaultdict(<class 'str'>, {})
>>> d['python']
''
>>> d
defaultdict(<class 'str'>, {'python': ''})

>>> d = {}                              # 普通字典调用不存在的键时，将会抛异常
>>> d['python']
Traceback (most recent call last):
  File "", line 1, in <module>
    d['python']
KeyError: 'python'

defaultdict 的一个典型用法是使用其中一种内置类型（如str、int、list或dict）作为默认参数（default_factory），因为这些内置类型在没有参数调用时返回空类型。

使用 list 作为 default_factory 的例子，可以很轻松地将（键-值对组成的）序列转换为（键-列表组成的）字典：

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = collections.defaultdict(list)
>>> for i, j in s:
	d[i].append(j)

	
>>> print(d)
defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
>>> print(sorted(d.items()))
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

4、collections.OrderedDict()

使用字典（dict）时，key 是无序的。在对字典做迭代时，无法确定 key 的顺序，而 OrderedDict 方法返回一个 dict 子类的实例，保留了添加顺序的字典对象，它具有专门用于重新排列字典顺序的方法。如果在已经存在的 key 上添加新的值，将会保留原来的 key 的位置，覆盖 value 值。

基本语法：collections.OrderedDict([items])

应用举例：

>>> import collections
>>> d = collections.OrderedDict()
>>> d['key1'] = 'value1'
>>> d['key2'] = 'value2'
>>> d['key3'] = 'value3'
>>> d['key4'] = 'value4'
>>> d
OrderedDict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'), ('key4', 'value4')])

5、collections.ChainMap()

基本语法：collections.ChainMap(*maps)

一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。 如果没有 maps 被指定，就提供一个默认的空字典，这样一个新链至少有一个映射。

ChainMap 本身也是一个字典，但是查找的时候，会按照顺序在内部的字典依次查找。

应用举例：

>>> import collections
>>> dict1 = {'A':1, 'B':2, 'C':3}
>>> dict2 = {'D':4, 'E':5, 'F':6}
>>> dict3 = collections.ChainMap(dict1, dict2)
>>> dict3
ChainMap({'A': 1, 'B': 2, 'C': 3}, {'D': 4, 'E': 5, 'F': 6})

>>> import collections
>>> dict1 = {'A':1, 'B':2}
>>> dict2 = {'A':3, 'C':4}
>>> dict3 = collections.ChainMap(dict1, dict2)
>>> print(dict3)
ChainMap({'A': 1, 'B': 2}, {'A': 3, 'C': 4})
>>> print(dict3['A'])                                # 搜索从左到右，先到先得
1

ChainMap 除了支持所有常用字典方法以外，还有以下三个方法：

① maps：一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，可以被修改。列表最少包含一个映射。

② new_child(m=None)：返回一个新的 ChainMap 类，包含了一个新映射(map)，后面跟随当前实例的全部映射(map)。如果 m 被指定，它就成为不同新的实例，就是在所有映射前加上 m，如果没有指定，就加上一个空字典，这样的话一个 d.new_child() 调用等价于 ChainMap({}, *d.maps)，这个方法用于创建子上下文，不改变任何父映射的值。

③ parents：属性返回一个新的 ChainMap 包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。 使用的场景类似在 nested scopes 嵌套作用域中使用 nonlocal 关键词。用例也可以类比内建函数 super() 。一个 d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。

应用举例：

import collections

dict1 = {'A':1, 'B':2}
dict2 = {'中文':3, '英文':4}
dict3 = {'C':'10', 'D':'20'}
dict4 = collections.ChainMap(dict1, dict2, dict3)
dict5 = dict4.new_child()
dict6 = dict4.new_child(m = dict2)
print('dict4 = ', dict4)
print('dict5 = ', dict5)
print('dict6 = ', dict6)
print('dict5.parents = ', dict5.parents)
print('dict6.parents = ', dict6.parents)

输出结果：

dict4 =  ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})
dict5 =  ChainMap({}, {'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})
dict6 =  ChainMap({'中文': 3, '英文': 4}, {'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})
dict5.parents =  ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})
dict6.parents =  ChainMap({'A': 1, 'B': 2}, {'中文': 3, '英文': 4}, {'C': '10', 'D': '20'})

6、collections.Counter()

一个 Counter 是一个 dict 的子类，用于计数可哈希对象。它是一个集合，元素像字典键（key）一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数。 Counter 类有点像其他语言中的 bags 或 multisets，另外，Counter 还支持算术和集合操作。简单来说，Counter 主要就是用来对访问的对象的频率进行计数。

基本语法：collections.Counter([iterable-or-mapping])

应用举例：

# 统计字符出现的次数
>>> import collections
>>> print(collections.Counter('hello world'))
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# 统计单词数
>>> import collections
>>> print(collections.Counter('hello world i love python hello python'.split()))
Counter({'hello': 2, 'python': 2, 'world': 1, 'i': 1, 'love': 1})

# 获取指定对象的访问次数，也可以使用get()方法
>>> import collections
>>> c = collections.Counter('hello world i love python hello python'.split())
>>> print(c['python'])	
2

常用的有以下四种方法：

① elements()：返回一个迭代器，其中每个元素将重复出现计数值所指定次，如果一个元素的计数小于1，就会被忽略。

>>> import collections
>>> c = collections.Counter(a=4, b=2, c=0, d=-2)
>>> print(c.elements())
<itertools.chain object at 0x000001940EF57C18>
>>> print(sorted(c.elements()))
['a', 'a', 'a', 'a', 'b', 'b']

② most_common([n])：返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。 如果 n 被省略或为 None，将返回计数器中的所有元素，计数值相等的元素按首次出现的顺序排序。

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

③ subtract([iterable-or-mapping])：从迭代对象或映射对象中减去元素。类似于 dict.update()，但是是减去，而不是替换，输入和输出都可以是0或者负数。

>>> import collections
>>> c = collections.Counter(a=4, b=2, c=0, d=-2)
>>> d = collections.Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

④ update([iterable-or-mapping])：从迭代对象计数元素或者从另一个映射对象 (或计数器) 添加。 类似于 dict.update() 但是是加上，而不是替换，另外，迭代对象应该是序列元素，而不是一个键值对。

>>> import collections
>>> c = collections.Counter('which')
>>> d = collections.Counter('witch')
>>> c.update(d)
>>> c
Counter({'h': 3, 'w': 2, 'i': 2, 'c': 2, 't': 1})