python collections模块--内建数据类型
基本介绍
除了Python内置的数据类型，比如str, int, list, tuple, dict等， collections模块在这些内置数据类型的基础上，提供了几个额外的数据类型：
| 函数名 | 说明 |
|---|---|
| namedtuple | 生成可以使用名字来访问元素内容的tuple子类 |
| deque | 双端队列，可以快速的从另外一侧追加和推出对象 |
| defaultdict | 带有默认值的字典 |
| OrderedDict | 有序字典 |
| Counter | 计数器，主要用来计数 |
| ChainMap | 组合多个map |
namedtuple
namedtuple主要用来产生可以使用名称来访问元素的数据对象，通常用来增强代码的可读性， 在访问一些tuple类型的数据时尤其好用。
示例：
import collections
Point = collections.namedtuple("Point", ("x", "y"))
p = Point(1, 2)
print(p, p.x, p.y)
输出：
Point(x=1, y=2) 1 2
deque
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈，除了list的方法外，还有如下方法：
| 函数名 | 说明 |
|---|---|
| appendleft | 队列左边添加元素 |
| extendleft | 队列左边扩展，可以是列表、元组或字典，如果是字典则将字典的key加入到deque |
| popleft | 移除并返回队列左边的元素 |
| rotate(n) | 对队列数进行移动 |
示例：
import collections
d = collections.deque([1, 2, 3, 4])
d.append(5)
d.appendleft(0)
print(d)
d.rotate(5) # 元素向前5位，类似于滚动效果
print(d)
输出：
deque([0, 1, 2, 3, 4, 5])
deque([1, 2, 3, 4, 5, 0])
deque
默认字典，字典的一个子类，继承所有字典的方法，但在Key不存在时会返回默认值。
使用defaultdict，只要你传入一个默认的工厂方法，那么请求一个不存在的key时， 便会调用这个工厂方法使用其结果来作为这个key的默认值。
示例：
import collections
s = [("yellow", 1), ("red", 2), ("yellow", 3), ("blue", 4), ("red", 1)]
dd = collections.defaultdict(list)
for k, v in s:
dd[k].append(v)
print(dd["black"])
print(dd)
dd2 = collections.defaultdict(lambda: None)
dd2["key1"] = 1
print(dd2["key2"])
print(dd2)
输出：
[]
defaultdict(<class 'list'>, {
'yellow': [1, 3], 'red': [2, 1], 'blue': [4], 'black': []})
None
defaultdict(<function <lambda> at 0x11779e378>, {
'key1': 1, 'key2': None})
虽然现在字典没有对应的键值，但仍然可以执行字典的update方法. 这种操作方式在传统的字典类型中是无法实现的,必须赋值以后才能进行值得更新操作，否则会报错。
OrderedDict
有序字典，也是字典的子类。Python中，dict这个数据结构由于hash的特性，是无序的。collections模块为我们提供了OrderedDict，来获得一个有序的字典对象。
示例：
import collections
od = collections.OrderedDict()
od["z"] = 3
od["y"] = 1
od["x"] = 2
print(list(od.keys()))
输出：
['z', 'y', 'x']
OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key：
from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict):
def __init__(self, capacity):
super(LastUpdatedOrderedDict, self).__init__()
self._capacity = capacity
def __setitem__(self, key, value):
containsKey = 1 if key in self else 0
if len(self) - containsKey >= self._capacity:
last = self.popitem(last=False)
print('remove:', last)
if containsKey:
del self[key]
print('set:', (key, value))
else:
print('add:', (key, value))
OrderedDict.__setitem__(self, key, value)
Counter
计数器，也是字典的子类，用来进行hashtable计数，将元素进行数量统计，计数后返回一个字典，键值为元素，值为元素个数。
常用方法：
| 函数名 | 说明 |
|---|---|
| most_common(int) | 按照元素出现的次数进行从高到低的排序，返回前int个元素的字典 |
| elements | 返回经过计算器Counter后的元素，返回的是一个迭代器 |
| update | 和set集合的update一样，对集合进行并集更新 |
| substract | 和update类似，只是update是做加法，substract做减法,从另一个集合中减去本集合的元素 |
示例：
import collections
str = "abbccabbbcca"
lst = ["a", "b", "c", "a", "b", "b"]
dic = {
"a": 3, "b": 17, "c": 4}
# 获取各元素个数，返回字典
print(collections.Counter(str))
print(collections.Counter(lst))
print(collections.Counter(dic))
# most_common(int), 返回最大的n个
d1 = collections.Counter(str)
print(d1.most_common(2))
# elements返回经过计算器Counter后的元素，返回的是一个迭代器
print(sorted(d1.elements()))
print("".join(d1.elements()))
输出：
Counter({
'b': 5, 'c': 4, 'a': 3})
Counter({
'b': 3, 'a': 2, 'c': 1})
Counter({
'b': 17, 'c': 4, 'a': 3})
[('b', 5), ('c', 4)]
['a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c']
aaabbbbbcccc
ChainMap
ChainMap可以把一组dict串起来并组成一个逻辑上的dict。ChainMap本身也是一个dict，但是查找的时候，会按照顺序在内部的dict依次查找。
示例：
# 初始化字典
dict1 = {
'a': 1, 'b': 2}
dict2 = {
'b': 3, 'c': 4}
# 初始化ChainMap
chain = collections.ChainMap(dict1, dict2)
# 使用maps输出chainMap
print(chain.maps)
# 输出key
print(list(chain.keys()))
# 输出值
print(list(chain.values()))
# 使用new_child添加新字典
dict3 = {
'f': 5}
new_chain = chain.new_child(dict3)
print(new_chain.maps)
输出：
[{
'a': 1, 'b': 2}, {
'b': 3, 'c': 4}]
['b', 'c', 'a']
[2, 4, 1]
[{
'f': 5}, {
'a': 1, 'b': 2}, {
'b': 3, 'c': 4}]
参考：https://www.cnblogs.com/zhizhan/p/5692668.html