collections 模块实现了专门的容器数据类型提供
Python通用内置容器的替代品,dict、list、set、tuple
OrderedDict
: 有序的字典namedtuple
: 用于创建具有命名字段的元组子类的工厂函数,返回一个具有命名字段的元组的新子类,可以用来构建一个只有少数属性,但没有方法的类对象Counter
: 计数器, 可以计算可哈希对象的Dict子类,可统计元素出现的次数deque
: 列表类容器,类似于列表的序列,支持从任意一端增加和删除元素defaultdict
: 字典的子类,提供了一个工厂函数,为字典查询提供一个默认值ChainMap
: 将多个映射快速的连接到一起UserDict
: 封装了字典对象,简化了字典子类化,继承字段使用UserDict, 不使用dictUserList
: 封装了列表对象,简化了列表子类化UserString
: 封装了字符串对象,简化了字符串子类化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}
返回一个具有命名字段的元组的新子类,可以用来构建一个只有少数属性,但没有方法的类对象
>>> 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)])
是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()
类似于列表的序列,支持从任意一端增加和删除元素
>>> 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'])
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类管理的是一个字典序列,并按其出现的顺序搜索以查找与键关联的值
比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'})
该类继承自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'