python 标准库之 collections 模块详解

collections 模块实现了专门的容器数据类型提供
Python通用内置容器的替代品，dict、list、set、tuple

• OrderedDict： 有序的字典
• namedtuple： 用于创建具有命名字段的元组子类的工厂函数,返回一个具有命名字段的元组的新子类，可以用来构建一个只有少数属性，但没有方法的类对象
• Counter： 计数器, 可以计算可哈希对象的Dict子类，可统计元素出现的次数
• deque： 列表类容器，类似于列表的序列，支持从任意一端增加和删除元素
• defaultdict： 字典的子类，提供了一个工厂函数，为字典查询提供一个默认值
• ChainMap： 将多个映射快速的连接到一起
• UserDict： 封装了字典对象，简化了字典子类化，继承字段使用UserDict, 不使用dict
• UserList： 封装了列表对象，简化了列表子类化
• UserString： 封装了字符串对象，简化了字符串子类化

OrderedDict

OrderedDict是dict的子类，和字典的操作完全相同
区别在于OrderedDict的Key会按照插入的顺序排列(不过从python3.6开始，dict的插入变为有序，即字典整体变的有序；)

>>> from collections import OrderedDict
>>> d = OrderedDict(x=1,y=2)
>>> d["a"] = 3
>>> print(d)
>>> OrderedDict([('x', 1), ('y', 2), ('a', 3)])
>>> d.get("a")
>>> 3
>>> d["a"]
>>> 3
>>> dict(d)
>>> {'x': 1, 'y': 2, 'a': 3}

namedtuple

返回一个具有命名字段的元组的新子类，可以用来构建一个只有少数属性，但没有方法的类对象

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__
>>> 'Point(x, y)'
>>> Point.x
>>> 
>>> p = Point(1,2)
>>> p.x
>>> 1
>>> d = p._asdict()
>>> d
>>> OrderedDict([('x', 1), ('y', 2)])

Counter

是dict的子类，同样具有dict相同的操作
以字典的形式返回序列中各个字符出现的次数，值为key，次数为value

>>> from collections import Counter
>>> c = Counter('abcdeabcdabcaba')
>>> c
>>> Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
>>> c.most_common(2)         # 获取出现次数最多的前两个元素
>>> [('a', 5), ('b', 4)]
>>> sorted(c)                 # 列出所有不同的元素并排序 
>>> ['a', 'b', 'c', 'd', 'e']
>>> c.elements()
>>> 
>>> ''.join(c.elements())       # 列出具有重复的元素
>>> 'aaaaabbbbcccdde'
>>> c.items()
>>> c.get("a")
>>> 5
>>> c["b"]
>>> 4
>>> d = Counter('simsalabim')
>>> d
>>> Counter({'s': 2, 'i': 2, 'm': 2, 'a': 2, 'l': 1, 'b': 1})
>>> c.update(d)
>>> c
>>> Counter({'a': 7, 'b': 5, 'c': 3, 'd': 2, 's': 2, 'i': 2, 'm': 2, 'e': 1, 'l': 1})
>>> c["a"]
>>> 7
>>> c.clear()
>>> c
>>> Counter()

deque

类似于列表的序列，支持从任意一端增加和删除元素

>>> from collections import deque
>>> l = deque()

>>> l
>>> deque([])

>>> l.append("a")               # 从右端增加元素 

>>> l
>>> deque(['a'])

>>> l.extend([1,2,3])

>>> l
>>> deque(['a', 1, 2, 3])

>>> l.appendleft(1)             # 从左端增加元素 

>>> l
>>> deque([1, 'a', 1, 2, 3])

>>> l.reverse()
>>> l
>>> deque([3, 2, 1, 'a', 1])

>>> l.count(1)
>>> 2

>>> l.remove(1)

>>> l
>>> deque([3, 2, 'a', 1])

>>> l.pop()
>>> 1

>>> l
>>> deque([3, 2, 'a'])

>>> l.insert(2, "123")

>>> l
>>> deque([3, 2, '123', 'a'])

defaultdict

dict的子类，拥有与dict相同的操作方法
defaultdict接受一个工厂函数作为参数来构造，将工厂函数的返回值作为dict的默认值

>>> from collections import defaultdict
>>> d = defaultdict()
>>> d
>>> defaultdict(None, {})

>>> d1 = defaultdict(int)
>>> d1["a"]
>>> 0

>>> d3 = defaultdict(list)
>>> d3
>>> defaultdict(, {})

>>> d3["a"].append(1)
>>> d3
>>> defaultdict(, {'a': [1]})

ChainMap

ChainMap类管理的是一个字典序列，并按其出现的顺序搜索以查找与键关联的值
比update更高效，其原理是将多个映射关系组织在一个列表中，不是创建一个新的对象，只是进行对象的引用，故原映射中值的改变会影响ChainMap，ChainMap中值的改变也会影响原映射关系

>>> from collections import ChainMap
>>> a = {"a": "A1", 'b': "B1"}
>>> b = {"b": "B2", "c": "C2"}
>>> d = ChainMap(a, b)

>>> d
>>> ChainMap({'a': 'A1', 'b': 'B1'}, {'b': 'B2', 'c': 'C2'})

>>> d.maps
>>> [{'a': 'A1', 'b': 'B1'}, {'b': 'B2', 'c': 'C2'}]

>>> d.get("b")                  # 获取key值，获取key值的时候从左到右，只返回第一个获取到的值
>>> 'B1'

>>> d["b"] = "BB"                # 更新值，只更新从左边开始发现的第一个key值

>>> d
>>> ChainMap({'a': 'A1', 'b': 'BB'}, {'b': 'B2', 'c': 'C2'})

>>> d = d.new_child(m={"a": "AA"})  # 在左边新插入一个字典
>>> d
>>> ChainMap({'a': 'AA'}, {'a': 'A1', 'b': 'BB'}, {'b': 'B2', 'c': 'C2'})

>>> d["a"]
>>> 'AA'

>>> d.parents               # 返回除第一个外的其他字典
>>> ChainMap({'a': 'A1', 'b': 'BB'}, {'b': 'B2', 'c': 'C2'})

UserDict

该类继承自MutableMapping,提供了一个可供继承的dict,
如下代码可以看到，继承自dict的类，重写了__getitem__方法却没有被get方法调用
而继承自UserDict的类，可以被get方法调用

>>> from collections import UserDict
>>> class D1(dict):
...     def __getitem__(self, item):
...         return f"{item} = {self.get(item)}"
    
>>> class D2(UserDict):
...     def __getitem__(self, item):
...         return f"{item} = {self.data.get(item)}"
     
>>> d1 = D1(a=1,b=2)
>>> d2 = D2(a=1, b=2)
>>> d1.get("a")
1
>>> d2.get("a")
'a = 1'