【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 "<pyshell#68>", 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})
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读