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