imtoken最新苹果安卓版|collections库 _比特派(Bitpie)官网-比特派钱包app官方下载-bitpie官网下载app

【万字长文详解】Python库collections，让你击败99%的Pythoner - 知乎

【万字长文详解】Python库collections，让你击败99%的Pythoner - 知乎首发于Python基础方法详解切换模式写文章登录/注册【万字长文详解】Python库collections，让你击败99%的Pythoner小伍哥聊风控风控算法、风控策略，反欺诈，异常检测，复杂网络挖掘、风控转行Python的集合（collections）模块，为很多用其他方法很难实现的场景提供了解决方案。本文我们将会学习该模块的抽象概念是如何产生的，日后处理不同问题的过程中迟早会用得到这些知识。免责声明：这篇文章是关于Python的一个相当高级的特性，如果你刚入门，建议先收藏，请等一等再学！没想到这篇文章这么受欢迎，修改优化下。一、模块概述1、模块作用官方说法：collections模块实现了特定目标的容器，以提供Python标准内建容器dict ,list , set , 和tuple的替代选择。通俗说法：Python内置的数据类型和方法，collections模块在这些内置类型的基础提供了额外的高性能数据类型，比如基础的字典是不支持顺序的，collections模块的OrderedDict类构建的字典可以支持顺序，collections模块的这些扩展的类用处非常大，熟练掌握该模块，可以大大简化Python代码，提高Python代码逼格和效率，高手入门必备。2、模块资料关于该模块，官方的参考资料写的非常详细，也很有价值，大家可以参考中文文档：https://docs.python.org/zh-cn/3/library/collections.html#module-collections英文文档：https://docs.python.org/3/library/collections.html#module-collections3、模块子类用collections.__all__查看所有的子类，一共包含9个import collections

print(collections.__all__)

['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList',

'UserString', 'Counter', 'OrderedDict', 'ChainMap']这个模块实现了特定目标的容器，以提供Python标准内建容器dict , list , set , 和tuple 的替代选择。namedtuple()创建命名元组子类的工厂函数，生成可以使用名字来访问元素内容的tuple子类deque类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)ChainMap类似字典(dict)的容器类，将多个映射集合到一个视图里面Counter字典的子类，提供了可哈希对象的计数功能OrderedDict字典的子类，保存了他们被添加的顺序，有序字典defaultdict字典的子类，提供了一个工厂函数，为字典查询提供一个默认值UserDict封装了字典对象，简化了字典子类化UserList封装了列表对象，简化了列表子类化UserString封装了字符串对象，简化了字符串子类化（中文版翻译有误）二、计数器-Counter1、基础介绍一个计数器工具提供快速和方便的计数，Counter是一个dict的子类，用于计数可哈希对象。它是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数，Counter类有点像其他语言中的bags或multisets。简单说，就是可以统计计数，来几个例子看看就清楚了，比如#计算top10的单词

from collections import Counter

import re

text = 'remove an existing key one level down remove an existing key one level down'

words = re.findall(r'\w+', text)

Counter(words).most_common(10)

[('remove', 2),('an', 2),('existing', 2),('key', 2),('one', 2)('level', 2),('down', 2)]

#计算列表中单词的个数

cnt = Counter()

for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:

cnt[word] += 1

cnt

Counter({'red': 2, 'blue': 3, 'green': 1})

#上述这样计算有点嘛，下面的方法更简单，直接计算就行

L = ['red', 'blue', 'red', 'green', 'blue', 'blue']

Counter(L)

Counter({'red': 2, 'blue': 3, 'green': 1}元素从一个iterable 被计数或从其他的mapping (or counter)初始化：from collections import Counter

#字符串计数

Counter('gallahad')

Counter({'g': 1, 'a': 3, 'l': 2, 'h': 1, 'd': 1})

#字典计数

Counter({'red': 4, 'blue': 2})

#是个啥玩意计数

Counter(cats=4, dogs=8)

Counter({'cats': 4, 'dogs': 8})

Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

Counter({'red': 2, 'blue': 3, 'green': 1})计数器对象除了字典方法以外，还提供了三个其他的方法：1、elements()描述：返回一个迭代器，其中每个元素将重复出现计数值所指定次。元素会按首次出现的顺序返回。如果一个元素的计数值小于1，elements() 将会忽略它。语法：elements( )参数：无c = Counter(a=4, b=2, c=0, d=-2)

list(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']

sorted(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']

c = Counter(a=4, b=2, c=0, d=5)

list(c.elements())

['a', 'a', 'a', 'a', 'b', 'b', 'd', 'd', 'd', 'd', 'd']2、most_common()返回一个列表，其中包含n个最常见的元素及出现次数，按常见程度由高到低排序。如果 n 被省略或为None，most_common() 将返回计数器中的所有元素，计数值相等的元素按首次出现的顺序排序，经常用来计算top词频的词语。Counter('abracadabra').most_common(3)

[('a', 5), ('b', 2), ('r', 2)]

Counter('abracadabra').most_common(5)

[('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]3、subtract()从迭代对象或映射对象减去元素。像dict.update() 但是是减去，而不是替换。输入和输出都可以是0或者负数。c = Counter(a=4, b=2, c=0, d=-2)

d = Counter(a=1, b=2, c=3, d=4)

c.subtract(d)

Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

#减去一个abcd

str0 = Counter('aabbccdde')

str0

Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2, 'e': 1})

str0.subtract('abcd')

str0

Counter({'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1}4、字典方法通常字典方法都可用于Counter对象，除了有两个方法工作方式与字典并不相同。fromkeys(iterable)这个类方法没有在Counter中实现。update([iterable-or-mapping])从迭代对象计数元素或者从另一个映射对象 (或计数器) 添加。像 dict.update() 但是是加上，而不是替换。另外，迭代对象应该是序列元素，而不是一个 (key, value) 对。sum(c.values()) # total of all counts

c.clear() # reset all counts

list(c) # list unique elements

set(c) # convert to a set

dict(c) # convert to a regular dictionary

c.items() # convert to a list of (elem, cnt) pairs

Counter(dict(list_of_pairs)) # convert from a list of (elem, cnt) pairs

c.most_common()[:-n-1:-1] # n least common elements

+c # remove zero and negative counts5、数学操作这个功能非常强大，提供了几个数学操作，可以结合 Counter 对象，以生产 multisets (计数器中大于0的元素）。加和减，结合计数器，通过加上或者减去元素的相应计数。交集和并集返回相应计数的最小或最大值。每种操作都可以接受带符号的计数，但是输出会忽略掉结果为零或者小于零的计数。c = Counter(a=3, b=1)

d = Counter(a=1, b=2)

c + d # add two counters together: c[x] + d[x]

Counter({'a': 4, 'b': 3})

c - d # subtract (keeping only positive counts)

Counter({'a': 2})

c & d # intersection: min(c[x], d[x])

Counter({'a': 1, 'b': 1})

c | d # union: max(c[x], d[x])

Counter({'a': 3, 'b': 2})单目加和减（一元操作符）意思是从空计数器加或者减去。c = Counter(a=2, b=-4)

Counter({'a': 2})

-c

Counter({'b': 4})写一个计算文本相似的算法，加权相似def str_sim(str_0,str_1,topn):

topn = int(topn)

collect0 = Counter(dict(Counter(str_0).most_common(topn)))

collect1 = Counter(dict(Counter(str_1).most_common(topn)))

jiao = collect0 & collect1

bing = collect0 | collect1

sim = float(sum(jiao.values()))/float(sum(bing.values()))

return(sim)

str_0 = '定位手机定位汽车定位GPS定位人定位位置查询'

str_1 = '导航定位手机定位汽车定位GPS定位人定位位置查询'

str_sim(str_0,str_1,5)

0.75 二、双向队列-deque双端队列，可以快速的从另外一侧追加和推出对象,deque是一个双向链表，针对list连续的数据结构插入和删除进行优化。它提供了两端都可以操作的序列，这表示在序列的前后你都可以执行添加或删除操作。双向队列(deque)对象支持以下方法：1、append()添加 x 到右端。d = deque('ghi')

d.append('j')

deque(['g', 'h', 'i', 'j'])2、appendleft()添加 x 到左端。d.appendleft('f')

deque(['f', 'g', 'h', 'i', 'j'])3、clear()移除所有元素，使其长度为0.d = deque('ghi')

d.clear()

deque([])4、copy()创建一份浅拷贝。d = deque('xiaoweuge')

y = d.copy()

print(y)

deque(['x', 'i', 'a', 'o', 'w', 'e', 'u', 'g', 'e'])5、count()计算 deque 中元素等于 x 的个数。d = deque('xiaoweuge-shuai')

d.count('a')

26、extend()扩展deque的右侧，通过添加iterable参数中的元素。a = deque('abc')

b = deque('cd')

a.extend(b)

deque(['a', 'b', 'c', 'c', 'd'])

#与append 的区别

a = deque('abc')

b = deque('cd')

a.append(b)

deque(['a', 'b', 'c', deque(['c', 'd'])])7、extendleft()扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。a = deque('abc')

b = deque('cd')

a.extendleft(b)

deque(['d', 'c', 'a', 'b', 'c'])8、index()返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前）。返回第一个匹配项，如果未找到则引发 ValueError。d = deque('xiaoweuge')

d.index('w')

49、insert()在位置 i 插入 x 。如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发一个 IndexError。a = deque('abc')

a.insert(1,'X')

deque(['a', 'X', 'b', 'c'])10、pop()移去并且返回一个元素，deque 最右侧的那一个。如果没有元素的话，就引发一个 IndexError。d.pop()

'j'11、popleft()移去并且返回一个元素，deque 最左侧的那一个。如果没有元素的话，就引发 IndexError。d.popleft()

'f'12、remove(value)移除找到的第一个 value。如果没有的话就引发 ValueError。a = deque('abca')

a.remove('a')

deque(['b', 'c', 'a'])13、reverse()将deque逆序排列。返回 None 。#逆序排列

d = deque('ghi') # 创建一个deque

list(reversed(d))

['i', 'h', 'g']

deque(reversed(d))

deque(['i', 'h', 'g'])14、rotate(n=1)向右循环移动 n 步。如果 n 是负数，就向左循环。如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ，向左循环一步就等价于 d.append(d.popleft()) 。# 向右边挤一挤

d = deque('ghijkl')

d.rotate(1)

deque(['l', 'g', 'h', 'i', 'j', 'k'])

# 向左边挤一挤

d.rotate(-1)

deque(['g', 'h', 'i', 'j', 'k', 'l'])

#看一个更明显的

x = deque('12345')

deque(['1', '2', '3', '4', '5'])

x.rotate()

deque(['5', '1', '2', '3', '4'])

d = deque(['12','av','cd'])

d.rotate(1)

deque(['cd', '12', 'av'15、maxlenDeque的最大尺寸，如果没有限定的话就是 None 。from collections import deque

d=deque(maxlen=10)

for i in range(20):

d.append(i)

deque([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])除了以上操作，deque还支持迭代、封存、len(d)、reversed(d)、copy.deepcopy(d)、copy.copy(d)、成员检测运算符 in 以及下标引用例如通过 d[0] 访问首个元素等。索引访问在两端的复杂度均为 O(1) 但在中间则会低至 O(n)。如需快速随机访问，请改用列表。Deque从版本3.5开始支持 __add__(), __mul__(), 和 __imul__() 。 from collections import deque

d = deque('ghi') # 创建一个deque

for elem in d:

print(elem.upper())

#从右边添加一个元素

d.append('j')

deque(['g', 'h', 'i', 'j'])

#从左边添加一个元素

d.appendleft('f')

deque(['f', 'g', 'h', 'i', 'j'])

#右边删除

d.pop()

'j'

#左边边删除

d.popleft()

'f'

#看看还剩下啥

list(d) #

['g', 'h', 'i']

#成员检测

'h' in d

True

#添加多个元素

d.extend('jkl')

deque(['g', 'h', 'i', 'j', 'k', 'l'])

d.clear() # empty the deque

d.pop() # cannot pop from an empty deque

Traceback (most recent call last):

File "", line 1, in -toplevel-

d.pop()

IndexError: pop from an empty deque

d.extendleft('abc') # extendleft() reverses the input order

deque(['c', 'b', 三、有序字典-OrderedDict 有序词典就像常规词典一样，但有一些与排序操作相关的额外功能,popitem() 方法有不同的签名。它接受一个可选参数来指定弹出哪个元素。move_to_end() 方法，可以有效地将元素移动到任一端。有序词典就像常规词典一样，但有一些与排序操作相关的额外功能。由于内置的 dict 类获得了记住插入顺序的能力（在 Python 3.7 中保证了这种新行为），它们变得不那么重要了。一些与 dict 的不同仍然存在：常规的 dict 被设计为非常擅长映射操作。跟踪插入顺序是次要的。OrderedDict 旨在擅长重新排序操作。空间效率、迭代速度和更新操作的性能是次要的。算法上， OrderedDict 可以比 dict 更好地处理频繁的重新排序操作。这使其适用于跟踪最近的访问（例如在 LRU cache 中）。对于 OrderedDict ，相等操作检查匹配顺序。OrderedDict 类的 popitem() 方法有不同的签名。它接受一个可选参数来指定弹出哪个元素。OrderedDict 类有一个 move_to_end() 方法，可以有效地将元素移动到任一端。Python 3.8之前， dict 缺少 __reversed__() 方法。传统字典方法OrderedDict方法差异clearclearcopycopyfromkeysfromkeysgetgetitemsitemskeyskeyspoppoppopitempopitemOrderedDict 类的 popitem() 方法有不同的签名。它接受一个可选参数来指定弹出哪个元素。setdefaultsetdefaultupdateupdatevaluesvaluesmove_to_end可以有效地将元素移动到任一端。1、popitem语法：popitem(last=True) 功能：有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。如果 last 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回键值对。from collections import OrderedDict

d = OrderedDict.fromkeys('abcde')

d.popitem()

('e', None)

OrderedDict([('a', None), ('b', None), ('c', None), ('d', None)])

#last=False时，弹出第一个

d = OrderedDict.fromkeys('abcde')

''.join(d.keys())

'abcde'

d.popitem(last=False)

''.join(d.keys())

'bcde'2、move_to_endfrom collections import OrderedDict

d = OrderedDict.fromkeys('abcde')

d.move_to_end('b')

''.join(d.keys())

'acdeb'

OrderedDict([('a', None), ('c', None), ('d', None), ('e', None), ('b', None)])

d.move_to_end('b', last=False)

''.join(d.keys())

'bacde'3、reversed()相对于通常的映射方法，有序字典还另外提供了逆序迭代的支持，通过reversed() 。 d = OrderedDict.fromkeys('abcde')

list(reversed(d))

['e', 'd', 'c', 'b', 'a']四、可命名元组-namedtuple生成可以使用名字来访问元素内容的tuple子类，命名元组赋予每个位置一个含义，提供可读性和自文档性。它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。1、参数介绍namedtuple(typename,field_names,*,verbose=False, rename=False, module=None)1）typename：该参数指定所创建的tuple子类的类名，相当于用户定义了一个新类。2）field_names：该参数是一个字符串序列，如 ['x'，'y']。此外，field_names 也可直接使用单个字符串代表所有字段名，多个字段名用空格、逗号隔开，如 'x y' 或 'x,y'。任何有效的 Python 标识符都可作为字段名（不能以下画线开头）。有效的标识符可由字母、数字、下画线组成，但不能以数字、下面线开头，也不能是关键字（如 return、global、pass、raise 等）。3）rename：如果将该参数设为 True，那么无效的字段名将会被自动替换为位置名。例如指定 ['abc','def','ghi','abc']，它将会被替换为 ['abc', '_1','ghi','_3']，这是因为 def 字段名是关键字，而 abc 字段名重复了。4）verbose：如果该参数被设为 True，那么当该子类被创建后，该类定义就被立即打印出来。5）module：如果设置了该参数，那么该类将位于该模块下，因此该自定义类的 __module__ 属性将被设为该参数值。2、应用案例1）水族箱案例Python元组是一个不可变的，或不可改变的，有序的元素序列。元组经常用来表示纵列数据;例如，一个CSV文件中的行数或一个SQL数据库中的行数。一个水族箱可以用一系列元组来记录它的鱼类的库存。一个单独的鱼类元组:这个元组由三个字符串元素组成。虽然在某些方面很有用，但是这个元组并没有清楚地指明它的每个字段代表什么。实际上，元素0是一个名称，元素1是一个物种，元素2是一个饲养箱。鱼类元组字段说明:这个表清楚地表明，该元组的三个元素都有明确的含义。来自collections模块的namedtuple允许你向一个元组的每个元素添加显式名称，以便在你的Python程序中明确这些元素的含义。让我们使用namedtuple来生成一个类，从而明确地命名鱼类元组的每个元素:from collections import namedtuple 可以让你的Python程序访问namedtuple工厂函数。namedtuple()函数调用会返回一个绑定到名称Fish的类。namedtuple()函数有两个参数:我们的新类“Fish”的期望名称和命名元素["name"、"species”、“tank"]的一个列表。我们可以使用Fish类来表示前面的鱼类元组:如果我们运行这段代码，我们将看到以下输出:sammy是使用Fish类进行实例化的。sammy是一个具有三个明确命名元素的元组。sammy的字段可以通过它们的名称或者一个传统的元组索引来访问:如果我们运行这两个print调用，我们将看到以下输出:访问.species会返回与使用[1]访问sammy的第二个元素相同的值。使用collections模块中的namedtuple可以在维护元组(即它们是不可变的、有序的)的重要属性的同时使你的程序更具可读性。此外，namedtuple工厂函数还会向Fish实例添加几个额外的方法。使用._asdict()将一个实例转换为字典:如果我们运行print，你会看到如下输出:在sammy上调用.asdict()将返回一个字典，该字典会将三个字段名称分别映射到它们对应的值。大于3.8的Python版本输出这一行的方式可能略有不同。例如，你可能会看到一个OrderedDict，而不是这里显示的普通字典。2）加法器案例from collections import namedtuple

# 定义命名元组类：Point

Point = namedtuple('Point', ['x', 'y'])

# 初始化Point对象，即可用位置参数，也可用命名参数

p = Point(11, y=22)

# 像普通元组一样用根据索引访问元素

print(p[0] + p[1])

#执行元组解包，按元素的位置解包

a, b = p

print(a, b)

11, 22

#根据字段名访问各元素

print(p.x + p.y)

print(p)

Point(x=11, y=22)3、三个方法备注: 在Python中，带有前导下划线的方法通常被认为是“私有的”。但是，namedtuple提供的其他方法(如._asdict()、._make()、._replace()等)是公开的。除了继承元组的方法，命名元组还支持三个额外的方法和两个属性。为了防止字段名冲突，方法和属性以下划线开始。_make(iterable)类方法从存在的序列或迭代实例创建一个新实例。t = [14, 55]

Point._make(t)_asdict()返回一个新的 dict ，它将字段名称映射到它们对应的值：p = Point(x=11, y=22)

p._asdict()

OrderedDict([('x', 11), ('y', 22)])_replace(**kwargs)返回一个新的命名元组实例，并将指定域替换为新的值p = Point(x=11, y=22)

p._replace(x=33)

Point(x=33, y=22)4、两个属性_fields字符串元组列出了字段名。用于提醒和从现有元组创建一个新的命名元组类型。p._fields # view the field names

('x', 'y')

Color = namedtuple('Color', 'red green blue')

Pixel = namedtuple('Pixel', Point._fields + Color._fields)

Pixel(11, 22, 128, 255, 0)

Pixel(x=11, y=22, red=128, green=255, blue=0)_field_defaults字典将字段名称映射到默认值。Account = namedtuple('Account', ['type', 'balance'], defaults=[0])

Account._field_defaults

{'balance': 0}

Account('premium')

Account(type='premium', balance=0)5、其他函数getattr()要获取这个名字域的值，使用 getattr() 函数 : getattr(p, 'x')

11转换一个字典到命名元组，使用 ** 两星操作符d = {'x': 11, 'y': 22}

Point(**d)

Point(x=11, y=22)因为一个命名元组是一个正常的Python类，它可以很容易的通过子类更改功能。这里是如何添加一个计算域和定宽输出打印格式:class Point(namedtuple('Point', ['x', 'y'])):

__slots__ = ()

@property

def hypot(self):

return (self.x ** 2 + self.y ** 2) ** 0.5

def __str__(self):

return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)

for p in Point(3, 4), Point(14, 5/7):

print(p)

Point: x= 3.000 y= 4.000 hypot= 5.000

Point: x=14.000 y= 0.714 hypot=14.018五、默认字典-defaultdict在Python字典中收集数据通常是很有用的。在字典中获取一个 key 有两种方法, 第一种 get , 第二种通过 [] 获取.使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict。当我使用普通的字典时，用法一般是dict={},添加元素的只需要dict[element] =value即，调用的时候也是如此，dict[element] = xxx,但前提是element字典里，如果不在字典里就会报错这时defaultdict就能排上用场了，defaultdict的作用是在于，当字典里的key不存在但被查找时，返回的不是keyError而是一个默认值，这个默认值是什么呢，下面会说1、基础介绍defaultdict([default_factory[, ...]])返回一个新的类似字典的对象。 defaultdict是内置dict类的子类。它重载了一个方法并添加了一个可写的实例变量。其余的功能与dict类相同，此处不再重复说明。本对象包含一个名为default_factory的属性，构造时，第一个参数用于为该属性提供初始值，默认为 None。所有其他参数（包括关键字参数）都相当于传递给 dict 的构造函数。defaultdict 对象除了支持标准 dict 的操作，还支持以下方法作为扩展：__missing__(key)如果 default_factory 属性为 None，则调用本方法会抛出 KeyError 异常，附带参数 key。如果 default_factory 不为 None，则它会被（不带参数地）调用来为 key 提供一个默认值，这个值和 key 作为一对键值对被插入到字典中，并作为本方法的返回值返回。如果调用 default_factory 时抛出了异常，这个异常会原封不动地向外层传递。在无法找到所需键值时，本方法会被 dict 中的 __getitem__() 方法调用。无论本方法返回了值还是抛出了异常，都会被 __getitem__() 传递。注意，__missing__() 不会被 __getitem__() 以外的其他方法调用。意味着 get() 会像正常的 dict 那样返回 None，而不是使用 default_factory。2、示例介绍使用 list 作为 default_factory，很轻松地将（键-值对组成的）序列转换为（键-列表组成的）字典 s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = defaultdict(list)

for k, v in s:

d[k].append(v)

sorted(d.items())

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]当每个键第一次遇见时，它还没有在字典里面，所以自动创建该条目，即调用default_factory方法，返回一个空的 list。 list.append() 操作添加值到这个新的列表里。当再次存取该键时，就正常操作，list.append() 添加另一个值到列表中。这个计数比它的等价方法dict.setdefault()要快速和简单： s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = {}

for k, v in s:

d.setdefault(k, []).append(v)

sorted(d.items())

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]设置 default_factory为int，使defaultdict用于计数（类似其他语言中的 bag或multiset）： s = 'mississippi'

d = defaultdict(int)

for k in s:

d[k] += 1

sorted(d.items())

[('i', 4), ('m', 1), ('p', 2), ('s', 4)]设置 default_factory 为 set 使 defaultdict 用于构建 set 集合： s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]

d = defaultdict(set)

for k, v in s:

d[k].add(v)

sorted(d.items())

[('blue', {2, 4}), ('red', {1, 3})]defaultdict绝不会引发一个KeyError。如果一个键不存在，defaultdict会插入并返回一个占位符值来代替:如果我们运行这段代码，我们将看到如下输出:defaultdict会插入并返回一个占位符值，而不是引发一个KeyError。在本例中，我们将占位符值指定为一个列表。相比之下，常规字典会在缺失的键上引发一个KeyError:如果我们运行这段代码，我们将看到如下输出:当我们试图访问一个不存在的键时，常规字典my_regular_dict会引发一个KeyError。defaultdict的行为与常规字典不同。defaultdict会不带任何参数调用占位符值来创建一个新对象，而不是在缺失的键上引发一个KeyError。在本例中，是调用list()创建一个空列表。继续我们虚构的水族箱示例，假设我们有一个表示水族箱清单的鱼类元组列表:水族箱中有三种鱼——它们的名字、种类和饲养箱在这三个元组中都有指出。我们的目标是按饲养箱组织我们的清单—我们想知道每个饲养箱中存在的鱼的列表。换句话说，我们需要一个能将“tank-a”映射到["Jamie", "Mary"] ，并且将“tank-b”映射到["Jamie"]的字典。我们可以使用defaultdict来按饲养箱对鱼进行分组:运行这段代码，我们将看到以下输出:fish_names_by_tank被声明为一个defaultdict，它默认会插入list()而不是引发一个KeyError。由于这保证了fish_names_by_tank中的每个键都将指向一个list，所以我们可以自由地调用.append()来将名称添加到每个饲养箱的列表中。这里，defaultdict帮助你减少了出现未预期的KeyErrors的机会。减少未预期的KeyErrors意味着你可以用更少的行更清晰地编写你的程序。更具体地说，defaultdict习惯用法让你避免了手动地为每个饲养箱实例化一个空列表。如果没有 defaultdict, for循环体可能看起来更像这样:使用常规字典(而不是defaultdict)意味着for循环体总是必须检查fish_names_by_tank中给定的tank是否存在。只有在验证了fish_names_by_tank中已经存在tank，或者已经使用一个[]初始化了tank之后，我们才可以添加鱼类名称。在填充字典时，defaultdict可以帮助我们减少样板代码，因为它从不引发KeyError。六、映射链-ChainMap 1、ChainMap是什么ChainMap最基本的使用，可以用来合并两个或者更多个字典，当查询的时候，从前往后依次查询。ChainMap：将多个字典视为一个，解锁Python超能力。ChainMap是由Python标准库提供的一种数据结构，允许你将多个字典视为一个。换句话说:ChainMap是一个基于多dict的可更新的视图，它的行为就像一个普通的dict。ChainMap类用于快速链接多个映射，以便将它们视为一个单元。它通常比创建新字典和多次调用update()快得多。你以前可能从来没有听说过ChainMap，你可能会认为ChainMap的使用情况是非常特定的。坦率地说，你是对的。我知道的用例包括：通过多个字典搜索提供链缺省值经常计算字典子集的性能关键的应用程序2、特性1）找到一个就不找了：这个列表是按照第一次搜索到最后一次搜索的顺序组织的，搜索查询底层映射，直到一个键被找到。2）更新原始映射：不同的是，写，更新和删除只操作第一个映射。3）支持所有常用字典方法。简而言之ChainMap：将多个字典视为一个，解锁Python超能力。Python标准库中的集合模块包含许多为性能而设计的实用的数据结构。著名的包括命名元组或计数器。今天，通过实例，我们来看看鲜为人知的ChainMap。通过浏览具体的示例，我希望给你一个提示，关于在更高级的Python工作中使用ChainMap将如何从中受益。3、应用案例-基础案例from collections import ChainMap

baseline = {'music': 'bach', 'art': 'rembrandt'}

adjustments = {'art': 'van gogh', 'opera': 'carmen'}

ChainMap(adjustments, baseline)

ChainMap({'art': 'van gogh', 'opera': 'carmen'}, {'music': 'bach', 'art': 'rembrandt'})

list(ChainMap(adjustments, baseline))

['music', 'art', 'opera']

#存在重复元素时，也不会去重

dcic1 = {'label1': '11', 'label2': '22'}

dcic2 = {'label2': '22', 'label3': '33'}

dcic3 = {'label4': '44', 'label5': '55'}

last = ChainMap(dcic1, dcic2,dcic3)

last

ChainMap({'label1': '11', 'label2': '22'}, {'label2': '22', 'label3': '33'}, {'label4': '44', 'label5': '55'})new_child()方法用法：new_child(m=None) 返回一个新的ChainMap类，包含了一个新映射(map)，后面跟随当前实例的全部映射map。如果m被指定，它就成为不同新的实例，就是在所有映射前加上 m，如果没有指定，就加上一个空字典，这样的话一个 d.new_child() 调用等价于ChainMap({}, *d.maps) 。这个方法用于创建子上下文，不改变任何父映射的值。last.new_child(m={'key_new':888})

ChainMap({'key_new': 888}, {'label1': '11', 'label2': '22'}, {'label2': '22', 'label3': '33'},

{'label4': '44', 'label5': '55'})parents属性属性返回一个新的ChainMap包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。使用的场景类似在 nested scopes 嵌套作用域中使用nonlocal关键词。用例也可以类比内建函数super() 。一个d.parents 的引用等价于ChainMap(*d.maps[1:]) 。last.parents

ChainMap({'label2': '22', 'label3': '33'}, {'label4': '44', 'label5': '55'})4、应用案例-购物清单作为使用ChainMap的第一个例子，让我们考虑一张购物清单。我们的清单可能包含玩具，电脑，甚至衣服。所有这些条目都有价格，所以我们将把我们的条目存储在名称价格映射中。toys = {'Blocks':30,'Monopoly':20}

computers = {'iMac':1000,'Chromebook':1000,'PC':400}

clothing = {'Jeans':40,'T-shirt':10}现在我们可以使用ChainMap在这些不同的集合上建立一个单一的视图：from collections import ChainMap

inventory = ChainMap(toys,computers,clothing)这使得我们可以查询清单，就像它是一个单一的字典：inventory['Monopoly']

inventory['Jeans']40正如官方文档所述，ChainMap支持所有常用的字典方法。我们可以使用.get()来搜索可能不存在的条目，或者使用 .pop()删除条目。inventory.get('Blocks-1')

None

inventory.get('Chromebook')

1000

inventory.pop('Blocks')

inventory

ChainMap({'Monopoly': 20}, {'iMac': 1000, 'Chromebook': 1000, 'PC': 400}, {'Jeans': 40, 'T-shirt': 10})如果我们现在把玩具添加到toys字典里，它也将在清单中可用。这是ChainMap的可更新的方面。toys['Nintendo'] = 20

inventory['Nintendo']

20Oh和ChainMap有一个恰当的字符串表示形式：str(inventory)

"ChainMap({'Monopoly': 20, 'Nintendo': 20}, {'iMac': 1000, 'Chromebook': 1000, 'PC': 400}, {'Jeans': 40, 'T-shirt': 10})"一个很好的特点是，在我们的例子中，toys, computers和clothing都是在相同的上下文中（解释器），它们可以来自完全不同的模块或包。这是因为ChainMap通过引用存储底层字典。第一个例子是使用ChainMap一次搜索多个字典。事实上，当构建ChainMap时，我们所做的就是有效地构建一系列字典。当查找清单中的一个项时，toys首先被查找，然后是computers，最后是clothing。ChainMap真的只是一个映射链！实际上，ChainMap的另一个任务是维护链的默认值。我们将以一个命令行应用程序的例子来说明这是什么意思。5、应用案例-CLI配置让我们面对现实，管理命令行应用程序的配置可能是困难的。配置来自多个源：命令行参数、环境变量、本地文件等。我们通常实施优先级的概念：如果A和B都定义参数P，A的P值将被使用，因为它的优先级高于B。例如，如果传递了命令行参数，我们可能希望在环境变量上使用命令行参数。如何轻松地管理配置源的优先级？一个答案是将所有配置源存储在ChainMap中。因为ChainMap中的查找是按顺序连续地对每个底层映射执行的（按照他们传给构造函数的顺序），所以我们可以很容易地实现我们寻找的优先级。下面是一个简单的命令行应用程序。调试参数从命令行参数、环境变量或硬编码默认值中提取：在执行脚本时，我们可以检查是否首先在命令行参数中查找debug，然后是环境变量，最后是默认值：这样看上去就非常整洁，对吧？6、我为什么关心？坦率地说，ChainMap是那些你可以忽略的Python特性之一。还有其他ChainMap的替代方案。例如，使用更新循环—例如创建一个dict并用字典update()它—可能奏效。但是，这只有在您不需要跟踪项目的起源时才有效，就像我们的多源CLI配置示例中的情况一样。但是，当你知道ChainMap存在的时候，ChainMap可以让你更轻松，你的代码更优雅。7、总结总而言之，我们一起看了ChainMap是什么，一些具体的使用示例，以及如何在现实生活中，性能关键的应用程序中使用ChainMap。如果您想了解更多关于Python的高性能数据容器的信息，请务必从Python的标准库中collections模块中查看其他出色类和函数。七、UserDict UserDict类是用作字典对象的外包装。对这个类的需求已部分由直接创建dict的子类的功能所替代；不过这个类处理起来更容易，因为底层的字典可以作为属性来访问。模拟一个字典类。这个实例的内容保存为一个正常字典，可以通过UserDict实例的data属性存取。如果提供了initialdata 值， data 就被初始化为它的内容，注意一个 initialdata 的引用不会被保留作为其他用途。UserDict 实例提供了以下属性作为扩展方法和操作的支持:data一个真实的字典，用于保存 UserDict 类的内容。八、UserList 这个类封装了列表对象。它是一个有用的基础类，对于你想自定义的类似列表的类，可以继承和覆盖现有的方法，也可以添加新的方法。这样我们可以对列表添加新的行为。对这个类的需求已部分由直接创建 list 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的列表可以作为属性来访问。模拟一个列表。这个实例的内容被保存为一个正常列表，通过 UserList 的 data 属性存取。实例内容被初始化为一个 list 的copy，默认为 [] 空列表。 list可以是迭代对象，比如一个Python列表，或者一个UserList 对象。UserList 提供了以下属性作为可变序列的方法和操作的扩展:data一个 list 对象用于存储 UserList 的内容。子类化的要求: UserList 的子类需要提供一个构造器，可以无参数调用，或者一个参数调用。返回一个新序列的列表操作需要创建一个实现类的实例。它假定了构造器可以以一个参数进行调用，这个参数是一个序列对象，作为数据源。如果一个分离的类不希望依照这个需求，所有的特殊方法就必须重写；请参照源代码进行修改。九、UserString UserString类是用作字符串对象的外包装。对这个类的需求已部分由直接创建str的子类的功能所替代，不过这个类处理起来更容易，因为底层的字符串可以作为属性来访问。模拟一个字符串对象。这个实例对象的内容保存为一个正常字符串，通过UserString的data属性存取。实例内容初始化设置为seq的copy。seq 参数可以是任何可通过内建str()函数转换为字符串的对象。UserString 提供了以下属性作为字符串方法和操作的额外支持：data一个真正的str对象用来存放 UserString 类的内容。编辑于 2022-04-08 11:36Python字典学习词频赞同 74028 条评论分享喜欢收藏申请转载文章被以下专栏收录Python基础方法详解介绍Python的基

Python——详解collections工具库 - 知乎

Python——详解collections工具库 - 知乎首发于TechFlow切换模式写文章登录/注册Python——详解collections工具库梁唐本文始发于个人公众号：TechFlow，原创不易，求个关注今天为大家介绍Python当中一个很好用也是很基础的工具库，叫做collections。collection在英文当中有容器的意思，所以顾名思义，这是一个容器的集合。这个库当中的容器很多，有一些不是很常用，本篇文章选择了其中最常用的几个，一起介绍给大家。defaultdictdefaultdict可以说是这个库当中使用最简单的一个，并且它的定义也很简单，我们从名称基本上就能看得出来。它解决的是我们使用dict当中最常见的问题，就是key为空的情况。在正常情况下，我们在dict中获取元素的时候，都需要考虑key为空的情况。如果不考虑这点，那么当我们获取了一个不存在的key，会导致系统抛出异常。我们当然可以在每次get之前写一个if判断，但是这很麻烦，比如：if key in dict:

return dict[key]

else:

return None当然，这是最笨的方法，dict当中为我们提供了带默认值的get方法。比如，我们可以写成：return dict.get(key, None)这样，当key不在dict当中存在的时候，会自动返回我们设置的默认值。这个省去了很多麻烦的判断，但是在一些特殊情况下仍然存在一点问题。举个例子，比如当key存在重复，我们希望将key相同的value存进一个list当中，而不是只保留一个。这种情况下写成代码就会比较复杂：data = [(1, 3), (2, 1), (1, 4), (2, 5), (3, 7)]

d = {}

for k, v in data:

if k in d:

d[k].append(v)

else:

d[k] = [v]由于dict的value是一个list，所以我们还是需要判断是否为空，不能直接使用默认值，间接操作当然可以，但是还是不够简单：for k, v in data:

cur = d.get(k, [])

cur.append(v)

d[k] = v这和使用if区别并不大，为了完美解决这个问题，我们可以使用collections当中的defaultdict：from collections import defaultdict

d = defaultdict(list)

for k, v in data:

d[k].append(v)使用defaultdict之后，如果key不存在，容器会自动返回我们预先设置的默认值。需要注意的是defaultdict传入的默认值可以是一个类型也可以是一个方法。如果我们传入int，那么默认值会被设置成int()的结果，也就是0，如果我们想要自定义或者修改，我们可以传入一个方法，比如：d = defaultdict(lambda: 3)

for k, v in data:

d[k] += vCounter这是一个非常常用和非常强大的工具，我们经常用到。在我们实际的编程当中，我们经常遇到一个问题，就是数数和排序。比如说我们在分析文本的时候，会得到一堆单词。其中可能有大量的长尾词，在整个文本当中可能只出现过寥寥几次。于是我们希望计算一下这些单词出现过的数量，只保留出现次数最高的若干个。这个需求让我们自己实现当然也不困难，我们完全可以创建一个dict，然后对这些单词一个一个遍历。原本我们还需要考虑单词之前没有出现过的情况，如果我们上面说的defaultdict，又要简单许多。但是我们还是少不了计数然后排序的步骤，如果使用Counter这个步骤会缩减成一行代码。举个例子：words = ['apple', 'apple', 'pear', 'watermelon', 'pear', 'peach']

from collections import Counter

counter = Counter(words)

>>> print(counter)

Counter({'apple': 2, 'pear': 2, 'watermelon': 1, 'peach': 1})我们直接将一个list传入Counter中作为参数，它会自动为我们替当中的每个元素计数。如果我们要筛选topK，也非常简单，它为我们提供了most_common方法，我们只需要传入需要求的K即可：counter.most_common(1)

[('apple', 2)]除此之外，它的构造函数还接收dict类型。我们可以直接通过一个value是int类型的dict来初始化一个Counter，比如：c = Counter({'apple': 5, 'pear': 4})

c = Counter(apple=4, pear=3)并且，它还支持加减法的操作，比如我们可以将两个Counter相加，它会自动将两个Counter合并，相同的key对应的value累加。相减也是同理，会将能对应的value做减法，被减的key对应不上的会保留，而减数中对应不上的key则会被丢弃。并且需要注意，Counter支持value为负数。deque我们都知道queue是队列，deque也是队列，不过稍稍特殊一些，是双端队列。对于queue来说，只允许在队尾插入元素，在队首弹出元素。而deque既然称为双端队列，那么说明它的队首和队尾都支持元素的插入和弹出。相比于普通的队列，要更加灵活一些。除了常用的clear、copy、count、extend等api之外，deque当中最常用也是最核心的api还有append、pop、appendleft和popleft。从名字上我们就看得出来，append和pop和list的append和pop一样，而appendleft和popleft则是在队列左侧，也就是头部进行pop和append的操作。非常容易理解。在日常的使用当中，真正用到双端队列的算法其实不太多。大多数情况下我们使用deque主要有两个原因，第一个原因是deque收到GIL的管理，它是线程安全的。而list则没有GIL锁，因此不是线程安全的。也就是说在并发场景下，list可能会导致一致性问题，而deque不会。另一个原因是deque支持固定长度，当长度满了之后，当我们继续append时，它会自动弹出最早插入的数据。比如说当我们拥有海量的数据，我们不知道它的数量，但是想要保留最后出现的指定数量的数据的时候，就可以使用deque。from collections import deque

dque = deque(maxlen=10)

# 假设我们想要从文件当中获取最后10条数据

for i in f.read():

dque.append(i)namedtuplenamedtuple很特殊，它涉及到元编程的概念。简单介绍一下元编程的概念，我们不做过多的深入。简而言之，就是在常见的面向对象当中。我们都是定义类，然后通过类的构造函数来创建实例。而元编程指的是我们定义元类，根据元类创建出来的并不是一个实例，而是一个类。如果用模具和成品来分别比喻类和实例的话，元类相当于是模具的模具。namedtuple是一个非常简单的元类，通过它我们可以非常方便地定义我们想要的类。它的用法很简单，我们直接来看例子。比如如果我们想要定义一个学生类，这个类当中有name、score、age这三个字段，那么这个类会写成：class Student:

def __init__(self, name=None, score=None, age=None):

self.name = name

self.score = score

self.age = age这还只是粗略的写法，如果考虑规范，还需要定义property等注解，又需要很多代码。如果我们使用namedtuple可以简化这个工作，我们来看代码：from collections import namedtuple

# 这个是类，columns也可以写成'name score age'，即用空格分开

Student = namedtuple('Student', ['name', 'score', 'age'])

# 这个是实例

student = Student(name='xiaoming', score=99, age=10)

print(student.name)通过使用namedtuple，我们只需要一行就定义了一个类，但是这样定义的类是没有缺失值的，但是namedtuple很强大，我们可以通过传入defaults参数来定义缺失值。Student = namedtuple('Student', ['name', 'score', 'age'], defaults=(0, 0))可以注意到，虽然我们定义了三个字段，但是我们只设置了两个缺失值。在这种情况下，namedtuple会自动将缺失值匹配上score和age两个字段。因为在Python的规范当中，必选参数一定在可选参数前面。所以nuamdtuple会自动右对齐。细数一下，我们今天的文章当中介绍了defaultdict、Counter、deque和namedtuple这四种数据结构的用法。除了这四个之外，collections库当中还有一些其他的工具类，只是我们用的频率稍稍低一些，加上由于篇幅的原因，这里就不多做赘述了。感兴趣的同学可以自行查看相关的api和文档。今天的文章就是这些，如果觉得有所收获，请顺手扫码点个关注吧，你们的举手之劳对我来说很重要。发布于 2020-03-03 08:44PythonPython 开发Python教程赞同 628 条评论分享喜欢收藏申请转载文章被以下专栏收录TechFlow简单文章，复

Python中 collections模块的详细用法介绍_python collections-CSDN博客

Python中 collections模块的详细用法介绍

最新推荐文章于 2023-09-05 17:34:50 发布

Python热爱者

最新推荐文章于 2023-09-05 17:34:50 发布

阅读量2.6w

300

点赞数

分类专栏：

Python基础

文章标签：

python

本文链接：https://blog.csdn.net/qdpython/article/details/120786550

版权

Python基础

专栏收录该内容

89 篇文章

60 订阅

订阅专栏

1. 介绍

collections是Python内建的一个集合模块，提供了许多有用的集合类和方法。

可以把它理解为一个容器，里面提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。

import collections

print(dir(collections))

# ['ChainMap', 'Counter', 'Mapping', 'MutableMapping', 'OrderedDict', 'UserDict', 'UserList', 'UserString', '_Link', '_OrderedDictItemsView', '_OrderedDictKeysView', '_OrderedDictValuesView', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__getattr__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '_chain', '_collections_abc', '_count_elements', '_eq', '_heapq', '_iskeyword', '_itemgetter', '_nt_itemgetters', '_proxy', '_recursive_repr', '_repeat', '_starmap', '_sys', 'abc', 'defaultdict', 'deque', 'namedtuple']

里面有许多方法，我们只介绍常用的方法。

2.常用方法

namedtuple() ：创建一个命名元组子类的工厂函数deque ：　　　高效增删改双向列表，类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)defaultdict ：当字典查询时，为key不存在提供一个默认值。OrderedDict ：有序词典，就是记住了插入顺序Counter ：计数功能

1. namedtuple() 命名元组

参数

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

typename ：　　命名的名字，返回一个新的元组子类，名为 typenamefield_names ：可以是一个[‘x’, ‘y’]这样的序列，也可以是’x, y’或者’x y’rename ：　　 python3.1添加，如果 rename 为真，无效域名会自动转换成位置名。比如 [‘abc’, ‘def’, ‘ghi’, ‘abc’] 转换成 [‘abc’, ‘_1’, ‘ghi’, ‘_3’] ，消除关键词 def 和重复域名 abc 。defaults ：　 python3.7添加， defaults 可以为 None 或者是一个默认值的 iterable（可迭代对象）。如果一个默认值域必须跟其他没有默认值的域在一起出现， defaults 就应用到最右边的参数。比如如果域名 [‘x’, ‘y’, ‘z’] 和默认值 (1, 2) ，那么 x 就必须指定一个参数值，y 默认值 1 ， z 默认值 2 。module ：　　 python3.6添加，如果 module 值有定义，命名元组的 __module__属性值就被设置。

使用

例如我想定义一个点(x, y)，可以给它起个名字为Points

'''

学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

import collections

point = collections.namedtuple('Points', ['x', 'y'])

p1 = point(2, 3)

p2 = point(4, 2)

print(p1) # Points(x=2, y=3)

print(p2) # Points(x=4, y=2)

用 isinstance 判断其类型

print(isinstance(p1, point)) # True

print(isinstance(p1, tuple)) # True

可以发现它即属于 point 类型，也属于 tuple 类型。

使用 _make 赋值

a= [11, 3]

p1._make(a)

print(p1) # Points(x=11, y=3)

使用 _replace 更改值

p1._replace(x=5)

print(p1) # Points(x=5, y=3)

2. deque 双端队列

参数

collections.deque([iterable[, maxlen]])

返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。

iterable ：迭代对象，可以是字符串，列表等可迭代对象。maxlen ： maxlen 没有指定或者是 None ， deque 可以增长到任意长度。否则， deque 就限定到指定最大长度。一旦限定长度的 deque 满了，当新项加入时，同样数量的项就从另一端弹出。

使用

'''

学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

from collections import deque

q = deque(['a', 'b', 'c'], maxlen=10)

# 从右边添加一个元素

q.append('d')

print(q) # deque(['a', 'b', 'c', 'd'], maxlen=10)

# 从左边删除一个元素

print(q.popleft()) # a

print(q) # deque(['b', 'c', 'd'], maxlen=10)

# 扩展队列

q.extend(['i', 'j'])

print(q) # deque(['b', 'c', 'd', 'i', 'j'], maxlen=10)

# 查找下标

print(q.index('c')) # 1

# 移除第一个'd'

q.remove('d')

print(q) # deque(['b', 'c', 'i', 'j'], maxlen=10)

# 逆序

q.reverse()

print(q) # deque(['j', 'i', 'c', 'b'], maxlen=10)

# 最大长度

print(q.maxlen) # 10

全部方法

append(x)：添加 x 到右端。

appendleft(x)：添加 x 到左端。

clear()：移除所有元素，使其长度为0.

copy()：创建一份浅拷贝。3.5 新版功能.

count(x)：计算deque中个数等于 x 的元素。3.2 新版功能.

extend(iterable)：扩展deque的右侧，通过添加iterable参数中的元素。

extendleft(iterable)：扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。

index(x[, start[, stop]])：返回第 x 个元素（从 start 开始计算，在 stop 之前）。返回第一个匹配，如果没找到的话，升起 ValueError 。3.5 新版功能.

insert(i, x)：在位置 i 插入 x 。如果插入会导致一个限长deque超出长度 maxlen 的话，就升起一个 IndexError 。3.5 新版功能.

pop()：移去并且返回一个元素，deque最右侧的那一个。如果没有元素的话，就升起 IndexError 索引错误。

popleft()：移去并且返回一个元素，deque最左侧的那一个。如果没有元素的话，就升起 IndexError 索引错误。

remove(value)：移去找到的第一个 value。如果没有的话就升起 ValueError 。

reverse()：将deque逆序排列。返回 None 。3.2 新版功能.

rotate(n=1)：向右循环移动 n 步。如果 n 是负数，就向左循环。如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ，向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

maxlen：Deque的最大尺寸，如果没有限定的话就是 None 。

3. defaultdict 默认值字典

使用

当key不存在时返回默认值

from collections import defaultdict

dd = defaultdict(lambda: 'not exist')

dd['key1'] = 'abc'

print(dd['key1']) # key1存在

# 'abc'

print(dd['key2']) # key2不存在，返回默认值

# 'not exist'

使用 list 作为 default_factory ，很容易将序列作为键值对加入字典:

'''

学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

from collections import defaultdict

d = defaultdict(list)

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

for k, v in s:

d[k].append(v)

print(d) # defaultdict(, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})

相当于

d = {}

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

for k, v in s:

d.setdefault(k, []).append(v)

print(d) # {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}

设置 default_factory 为 int ，可以很好的用于计数

s = 'mississippi'

d = defaultdict(int)

for k in s:

d[k] += 1

print(d) # defaultdict(, {'m': 1, 'i': 4, 's': 4, 'p': 2})

4. OrderedDict 有序字典

有序词典就像常规词典一样，但有一些与排序操作相关的额外功能。

但是内置的 dict 类已经有了记住插入顺序的能力（在 Python 3.7 中保证了这种新行为），所以它变得不那么重要了。

使用

popitem(last=True) ：有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。如果 last 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回键值对。

'''

学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

from collections import OrderedDict

d = OrderedDict(a=1, b=2, c=3, d=4,e=5)

print(d) # OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])

print(d.popitem(last=True)) # ('e', 5)

print(d.popitem(last=False)) # ('a', 1)

print(d) # OrderedDict([('b', 2), ('c', 3), ('d', 4)]

move_to_end(key, last=True)：将现有 key 移动到有序字典的任一端。如果 last 为真值（默认）则将元素移至末尾；如果 last 为假值则将元素移至开头。如果 key 不存在则会触发 KeyError。

from collections import OrderedDict

d = OrderedDict(a=1, b=2, c=3, d=4,e=5)

print(d) # OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])

d.move_to_end(key='c', last=True)

print(d) # OrderedDict([('a', 1), ('b', 2), ('d', 4), ('e', 5), ('c', 3)])

d.move_to_end(key='b', last=False)

print(d) # OrderedDict([('b', 2), ('a', 1), ('d', 4), ('e', 5), ('c', 3)])

5. Counter 计数

Counter 是一个 dict 的子类，用于计数可哈希对象。特别方便！

使用

字符串

from collections import Counter

c = Counter()

for i in 'sfsadfsdjklgsdla':

c[i] += 1

print(isinstance(c,Counter)) # True

print(isinstance(c,dict)) # True

print(c) # Counter({'s': 4, 'd': 3, 'f': 2, 'a': 2, 'l': 2, 'j': 1, 'k': 1, 'g': 1})

c2 = Counter('asfjslfjsdlfjgkls')

print(c2) # Counter({'s': 4, 'd': 3, 'f': 2, 'a': 2, 'l': 2, 'j': 1, 'k': 1, 'g': 1})

列表

'''

学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

from collections import Counter

c = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

print(c) # Counter({'blue': 3, 'red': 2, 'green': 1})

elements() ：返回一个迭代器，其中每个元素将重复出现计数值所指定次。元素会按首次出现的顺序返回。如果一个元素的计数值小于一， elements() 将会忽略它。

c = Counter(a=4, b=2, c=0, d=-2)

print(sorted(c.elements())) # ['a', 'a', 'a', 'a', 'b', 'b']

most_common([n]) ：返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。如果 n 被省略或为 None， most_common() 将返回计数器中的所有元素。计数值相等的元素按首次出现的顺序排序：

c = Counter('abracadabra')

print(c.most_common(3)) # [('a', 5), ('b', 2), ('r', 2)]

subtract([iterable-or-mapping]) ：从迭代对象或映射对象减去元素。像 dict.update() 但是是减去，而不是替换。输入和输出都可以是0或者负数。

c = Counter(a=4, b=2, c=0, d=-2)

d = Counter(a=1, b=2, c=3, d=4)

c.subtract(d)

print(c) # Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

优惠劵

Python热爱者

关注

踩

300

觉得还不错?

一键收藏

知道了

Python中 collections模块的详细用法介绍

1. 介绍collections是Python内建的一个集合模块，提供了许多有用的集合类和方法。可以把它理解为一个容器，里面提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。import collectionsprint(dir(collections))# ['ChainMap', 'Counter', 'Mapping', 'MutableMapping', 'OrderedDict', 'UserDict', 'UserList', 'Use

复制链接

扫一扫

专栏目录

Python collections模块的使用方法

12-16

collections模块

这个模块实现了特定目标的容器，以提供Python标准内建容器 dict、list、set、tuple 的替代选择。

Counter：字典的子类，提供了可哈希对象的计数功能

defaultdict：字典的子类，提供了一个工厂函数，为字典查询提供了默认值

OrderedDict：字典的子类，保留了他们被添加的顺序

namedtuple：创建命名元组子类的工厂函数

deque：类似列表容器，实现了在两端快速添加(append)和弹出(pop)

ChainMap：类似字典的容器类，将多个映射集合到一个视图里面

Counter

Counter是一个di

python中的 collections 模块(用法、详解、底层原理，示例等)

Mogul的博客

06-05

2404

# python中的 collections 模块

## 1、collections 模块中的 defaultdict

### 1.1 defaultdict 功能

`可以设置一个默认值作为字典中新key的默认值。该默认值可以是任何对象，

包括函数、列表、元组、集合等。默认值不需要像dict那样事先定义，因为它在需要的时候会自动创建`

`使用defaultdict，可以简化代码并提高代码的可读性，而且可以防止KeyError异常的出现。同时，defaultdict的性能与普通字典相当，因为底层实现并不

4 条评论

您还未登录，请先

后发表或查看评论

每日一课 | 详解collections工具库，一篇文章全搞定！

sinat_32849897的博客

09-18

318

作者：梁唐今日知识点collections正文前言大家好，今天为大家介绍Python当中一个很好用也是很基础的工具库，叫做collectionscollection在英文当中有容器的意...

Python入门：Python模块collections

ysds20211402的博客

01-20

1911

转自：微点阅读https://www.weidianyuedu.com/content/1817388341618.html

Python的内置模块collections有几个关键的数据结构，平常在使用的时候，开发者可以直接调用，不需要自己重复制造轮子，这样可以提高开发效率。

1. deque双端队列平常我们使用的python内置list类的append，extend，pop方法都是从list的尾部执行的（pop()默认弹出最后一个元素）。在使用的时候，list很像是一种栈结构（LIFO）。不同..

[编程基础] Python内置模块collections使用笔记

collections --- 容器数据类型 — Python 3.12.2 文档

Theme

Auto

Light

Dark

collections --- 容器数据类型

ChainMap 对象

ChainMap 例子和方法

Counter 对象

deque 对象

deque 用法

defaultdict 对象

defaultdict 例子

namedtuple() 命名元组的工厂函数

OrderedDict 对象

OrderedDict 例子和用法

UserDict 对象

UserList 对象

UserString 对象

上一主题

calendar --- 日历相关函数

下一主题

collections.abc --- 容器的抽象基类

当前页面

报告 Bug

显示源码

导航

索引

模块 |

下一页 |

上一页 |

Python »

3.12.2 Documentation »

Python 标准库 »

数据类型 »

collections --- 容器数据类型

Theme

Auto

Light

Dark

collections --- 容器数据类型¶

源代码： Lib/collections/__init__.py

这个模块实现了一些专门化的容器，提供了对 Python 的通用内建容器 dict、list、set 和 tuple 的补充。

namedtuple()

一个工厂函数，用来创建元组的子类，子类的字段是有名称的。

deque

类似列表的容器，但 append 和 pop 在其两端的速度都很快。

ChainMap

类似字典的类，用于创建包含多个映射的单个视图。

Counter

用于计数 hashable 对象的字典子类

OrderedDict

字典的子类，能记住条目被添加进去的顺序。

defaultdict

字典的子类，通过调用用户指定的工厂函数，为键提供默认值。

UserDict

封装了字典对象，简化了字典子类化

UserList

封装了列表对象，简化了列表子类化

UserString

封装了字符串对象，简化了字符串子类化

ChainMap 对象¶

在 3.3 版本加入.

ChainMap 类将多个映射迅速地链到一起，这样它们就可以作为一个单元处理。这通常比创建一个新字典再重复地使用 update() 要快得多。

这个类可以用于模拟嵌套作用域，并且对模版化有用。

class collections.ChainMap(*maps)¶

一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。如果没有指定任何 maps，一个空字典会被作为 maps。这样，每个新链至少包含一个映射。

底层映射被存储在一个列表中。这个列表是公开的，可以通过 maps 属性存取和更新。没有其他的状态。

搜索查询底层映射，直到一个键被找到。不同的是，写，更新和删除只操作第一个映射。

一个 ChainMap 通过引用合并底层映射。所以，如果一个底层映射更新了，这些更改会反映到 ChainMap 。

支持所有常用字典方法。另外还有一个 maps 属性(attribute)，一个创建子上下文的方法(method)，一个存取它们首个映射的属性(property):

maps¶

一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，可以被修改。列表最少包含一个映射。

new_child(m=None, **kwargs)¶

返回一个新的 ChainMap，其中包含一个新的映射，后面跟随当前实例中的所有映射。如果指定了 m，它会成为新的映射加在映射列表的前面；如果未指定，则会使用一个空字典，因此调用 d.new_child() 就等价于 ChainMap({}, *d.maps)。如果指定了任何关键字参数，它们会更新所传入的映射或新的空字典。此方法被用于创建子上下文，它可在不改变任何上级映射的情况下被更新。

在 3.4 版本发生变更: 添加了可选的 m 形参。

在 3.10 版本发生变更: 增加了对关键字参数的支持。

parents¶

属性返回一个新的 ChainMap 包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。使用的场景类似在 nested scopes 嵌套作用域中使用 nonlocal 关键词。用例也可以类比内建函数 super() 。一个 d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。

注意，一个 ChainMap() 的迭代顺序是通过从后往前扫描所有映射来确定的:

>>> baseline = {'music': 'bach', 'art': 'rembrandt'}

>>> adjustments = {'art': 'van gogh', 'opera': 'carmen'}

>>> list(ChainMap(adjustments, baseline))

['music', 'art', 'opera']

使得顺序与从最后一个映射开始调用一系列 dict.update() 得到的字典的迭代顺序相同：

>>> combined = baseline.copy()

>>> combined.update(adjustments)

>>> list(combined)

['music', 'art', 'opera']

在 3.9 版本发生变更: 增加了对 | 和 |= 运算符的支持，相关说明见 PEP 584。

参见

MultiContext class 在 Enthought CodeTools package 有支持写映射的选项。

Django 中用于模板的 Context class 是只读的映射链。它还具有上下文推送和弹出特性，类似于 new_child() 方法和 parents 特征属性。

Nested Contexts recipe 提供了是否对第一个映射或其他映射进行写和其他修改的选项。

一个极简的只读版 Chainmap.

ChainMap 例子和方法¶

这一节提供了多个使用链映射的案例。

模拟Python内部lookup链的例子

import builtins

pylookup = ChainMap(locals(), globals(), vars(builtins))

让用户指定的命令行参数优先于环境变量，优先于默认值的例子

import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()

parser.add_argument('-u', '--user')

parser.add_argument('-c', '--color')

namespace = parser.parse_args()

command_line_args = {k: v for k, v in vars(namespace).items() if v is not None}

combined = ChainMap(command_line_args, os.environ, defaults)

print(combined['color'])

print(combined['user'])

用 ChainMap 类模拟嵌套上下文的例子

c = ChainMap() # Create root context

d = c.new_child() # Create nested child context

e = c.new_child() # Child of c, independent from d

e.maps[0] # Current context dictionary -- like Python's locals()

e.maps[-1] # Root context -- like Python's globals()

e.parents # Enclosing context chain -- like Python's nonlocals

d['x'] = 1 # Set value in current context

d['x'] # Get first key in the chain of contexts

del d['x'] # Delete from current context

list(d) # All nested values

k in d # Check all nested values

len(d) # Number of nested values

d.items() # All nested items

dict(d) # Flatten into a regular dictionary

ChainMap 类只更新链中的第一个映射，但lookup会搜索整个链。然而，如果需要深度写和删除，也可以很容易的通过定义一个子类来实现它

class DeepChainMap(ChainMap):

'Variant of ChainMap that allows direct updates to inner scopes'

def __setitem__(self, key, value):

for mapping in self.maps:

if key in mapping:

mapping[key] = value

return

self.maps[0][key] = value

def __delitem__(self, key):

for mapping in self.maps:

if key in mapping:

del mapping[key]

return

raise KeyError(key)

>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})

>>> d['lion'] = 'orange' # update an existing key two levels down

>>> d['snake'] = 'red' # new keys get added to the topmost dict

>>> del d['elephant'] # remove an existing key one level down

>>> d # display result

DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

Counter 对象¶

一个计数器工具，为的是可以方便快速地计账。例如：

>>> # Tally occurrences of words in a list

>>> cnt = Counter()

>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:

... cnt[word] += 1

...

>>> cnt

Counter({'blue': 3, 'red': 2, 'green': 1})

>>> # Find the ten most common words in Hamlet

>>> import re

>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())

>>> Counter(words).most_common(10)

[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),

('you', 554), ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]

class collections.Counter([iterable-or-mapping])¶

Counter 是 dict 的子类，用于计数 hashable 对象。它是一个多项集，元素存储为字典的键而它们的计数存储为字典的值。计数可以是任何整数，包括零或负的计数值。Counter 类与其他语言中的 bag 或 multiset 很相似。

它可以通过计数一个 iterable 中的元素来初始化，或用其它 mapping (包括 counter) 初始化：

>>> c = Counter() # a new, empty counter

>>> c = Counter('gallahad') # a new counter from an iterable

>>> c = Counter({'red': 4, 'blue': 2}) # a new counter from a mapping

>>> c = Counter(cats=4, dogs=8) # a new counter from keyword args

Counter 对象的接口类似于字典，不同的是，如果查询的键不在 Counter 中，它会返回一个 0 而不是引发一个 KeyError：

>>> c = Counter(['eggs', 'ham'])

>>> c['bacon'] # count of a missing element is zero

设置一个计数为0不会从计数器中移去一个元素。使用 del 来删除它:

>>> c['sausage'] = 0 # counter entry with a zero count

>>> del c['sausage'] # del actually removes the entry

在 3.1 版本加入.

在 3.7 版本发生变更: 作为 dict 的子类，Counter 继承了记住插入顺序的功能。Counter 对象间的数学运算也是保序的。结果首先把左操作数中存在的元素按照它们在左操作数中的顺序排序，后面跟着其它元素，按它们在右操作数中的顺序排序。

Counter 对象在对所有字典可用的方法以外还支持一些附加方法:

elements()¶

返回一个迭代器，其中每个元素将重复出现计数值所指定次。元素会按首次出现的顺序返回。如果一个元素的计数值小于一，elements() 将会忽略它。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> sorted(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])¶

返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。如果 n 被省略或为 None，most_common() 将返回计数器中的所有元素。计数值相等的元素按首次出现的顺序排序：

>>> Counter('abracadabra').most_common(3)

[('a', 5), ('b', 2), ('r', 2)]

subtract([iterable-or-mapping])¶

减去一个可迭代对象或映射对象 (或 counter) 中的元素。类似于 dict.update() 但是是减去而非替换。输入和输出都可以是 0 或负数。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> d = Counter(a=1, b=2, c=3, d=4)

>>> c.subtract(d)

>>> c

Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

在 3.2 版本加入.

total()¶

计算总计数值。

>>> c = Counter(a=10, b=5, c=0)

>>> c.total()

在 3.10 版本加入.

通常字典方法都可用于 Counter 对象，除了有两个方法工作方式与字典并不相同。

fromkeys(iterable)¶

这个类方法没有在 Counter 中实现。

update([iterable-or-mapping])¶

加上一个可迭代对象或映射对象 (或 counter) 中的元素。类似于 dict.update() 但是是加上而非替换。另外，可迭代对象应当是一个元素序列，而不是一个 (key, value) 对的序列。

计数对象支持相等性、子集和超集关系等富比较运算符: ==, !=, <, <=, >, >=。所有这些检测会将不存在的元素当作计数值为零，因此 Counter(a=1) == Counter(a=1, b=0) 将返回真值。

在 3.10 版本加入: 增加了富比较运算。

在 3.10 版本发生变更: 在相等性检测中，不存在的元素会被当作计数值为零。在此之前，Counter(a=3) 和 Counter(a=3, b=0) 会被视为不同。

Counter 对象的常用案例

c.total() # total of all counts

c.clear() # reset all counts

list(c) # list unique elements

set(c) # convert to a set

dict(c) # convert to a regular dictionary

c.items() # convert to a list of (elem, cnt) pairs

Counter(dict(list_of_pairs)) # convert from a list of (elem, cnt) pairs

c.most_common()[:-n-1:-1] # n least common elements

+c # remove zero and negative counts

提供了几种数学运算用来合并 Counter 对象，产生多集（所有计数值均大于零的 counter）。加减运算通过增加或减少两者间对应元素的计数来合并 counter。交并运算返回对应计数的最小值和最大值。相等和包含运算比较对应的计数。每个运算的参数都可以含有有符号的计数，但输出将排除计数小于等于零的元素。

>>> c = Counter(a=3, b=1)

>>> d = Counter(a=1, b=2)

>>> c + d # add two counters together: c[x] + d[x]

Counter({'a': 4, 'b': 3})

>>> c - d # subtract (keeping only positive counts)

Counter({'a': 2})

>>> c & d # intersection: min(c[x], d[x])

Counter({'a': 1, 'b': 1})

>>> c | d # union: max(c[x], d[x])

Counter({'a': 3, 'b': 2})

>>> c == d # equality: c[x] == d[x]

False

>>> c <= d # inclusion: c[x] <= d[x]

False

单目加和减（一元操作符）意思是从空计数器加或者减去。

>>> c = Counter(a=2, b=-4)

>>> +c

Counter({'a': 2})

>>> -c

Counter({'b': 4})

在 3.3 版本加入: 添加了对一元加，一元减和位置集合操作的支持。

备注

计数器主要是为了表达运行的正的计数而设计；但是，小心不要预先排除负数或者其他类型。为了帮助这些用例，这一节记录了最小范围和类型限制。

Counter 类是一个字典的子类，不限制键和值。值用于表示计数，但你实际上可以存储任何其他值。

most_common() 方法在值需要排序的时候用。

参与原地操作如 c[key] += 1 的值的类型只需要支持加和减，所以分数、小数和 decimals 都可以用，也支持负数。update() 和 subtract() 当然也一样，输入和输出都支持 0 和负数。

多集方法是专为只会遇到正值的使用情况设计的。输入可以是 0 或负数，但只输出计数为正的值。没有类型限制，但值的类型需支持加、减和比较操作。

elements() 方法要求正整数计数。忽略0和负数计数。

参见

Bag class 在 Smalltalk。

Wikipedia 链接 Multisets.

C++ multisets 教程和例子。

数学操作和多集合用例，参考 Knuth, Donald. The Art of Computer Programming Volume II, Section 4.6.3, Exercise 19 。

在给定数量和集合元素枚举所有不同的多集合，参考 itertools.combinations_with_replacement()

map(Counter, combinations_with_replacement('ABC', 2)) # --> AA AB AC BB BC CC

deque 对象¶

class collections.deque([iterable[, maxlen]])¶

返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。

Deque 队列是对栈或 queue 队列的泛化（该名称的发音为 "deck"，是 "double-ended queue" 的简写形式)。 Deque 支持线程安全，高度节省内存地从 deque 的任一端添加和弹出条目，在两个方向上的大致性能均为 O(1)。

虽然 list 对象也支持类似的操作，但它们是针对快速的固定长度的操作进行优化而 pop(0) 和 insert(0, v) 操作对下层数据表示的大小和位置改变都将产生 O(n) 的内存移动开销。

如果 maxlen 没有指定或者是 None ，deques 可以增长到任意长度。否则，deque就限定到指定最大长度。一旦限定长度的deque满了，当新项加入时，同样数量的项就从另一端弹出。限定长度deque提供类似Unix filter tail 的功能。它们同样可以用与追踪最近的交换和其他数据池活动。

双向队列(deque)对象支持以下方法：

append(x)¶

添加 x 到右端。

appendleft(x)¶

添加 x 到左端。

clear()¶

移除所有元素，使其长度为0.

copy()¶

创建一份浅拷贝。

在 3.5 版本加入.

count(x)¶

计算 deque 中元素等于 x 的个数。

在 3.2 版本加入.

extend(iterable)¶

扩展deque的右侧，通过添加iterable参数中的元素。

extendleft(iterable)¶

扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。

index(x[, start[, stop]])¶

返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前）。返回第一个匹配项，如果未找到则引发 ValueError。

在 3.5 版本加入.

insert(i, x)¶

在位置 i 插入 x 。

如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发一个 IndexError。

在 3.5 版本加入.

pop()¶

移去并且返回一个元素，deque 最右侧的那一个。如果没有元素的话，就引发一个 IndexError。

popleft()¶

移去并且返回一个元素，deque 最左侧的那一个。如果没有元素的话，就引发 IndexError。

remove(value)¶

移除找到的第一个 value。如果没有的话就引发 ValueError。

reverse()¶

将deque逆序排列。返回 None 。

在 3.2 版本加入.

rotate(n=1)¶

向右循环移动 n 步。如果 n 是负数，就向左循环。

如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ，向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

maxlen¶

Deque的最大尺寸，如果没有限定的话就是 None 。

在 3.1 版本加入.

在上述操作以外，deque 还支持迭代, 封存, len(d), reversed(d), copy.copy(d), copy.deepcopy(d), 使用 in 运算符的成员检测以及下标引用例如通过 d[0] 访问首个元素等。索引访问在两端的时间复杂度均为 O(1) 但在中间则会低至 O(n)。对于快速随机访问，请改用列表。

Deque从版本3.5开始支持 __add__(), __mul__(), 和 __imul__() 。

示例:

>>> from collections import deque

>>> d = deque('ghi') # make a new deque with three items

>>> for elem in d: # iterate over the deque's elements

... print(elem.upper())

>>> d.append('j') # add a new entry to the right side

>>> d.appendleft('f') # add a new entry to the left side

>>> d # show the representation of the deque

deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop() # return and remove the rightmost item

'j'

>>> d.popleft() # return and remove the leftmost item

'f'

>>> list(d) # list the contents of the deque

['g', 'h', 'i']

>>> d[0] # peek at leftmost item

'g'

>>> d[-1] # peek at rightmost item

'i'

>>> list(reversed(d)) # list the contents of a deque in reverse

['i', 'h', 'g']

>>> 'h' in d # search the deque

True

>>> d.extend('jkl') # add multiple elements at once

>>> d

deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> d.rotate(1) # right rotation

>>> d

deque(['l', 'g', 'h', 'i', 'j', 'k'])

>>> d.rotate(-1) # left rotation

>>> d

deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d)) # make a new deque in reverse order

deque(['l', 'k', 'j', 'i', 'h', 'g'])

>>> d.clear() # empty the deque

>>> d.pop() # cannot pop from an empty deque

Traceback (most recent call last):

File "", line 1, in -toplevel-

d.pop()

IndexError: pop from an empty deque

>>> d.extendleft('abc') # extendleft() reverses the input order

>>> d

deque(['c', 'b', 'a'])

deque 用法¶

这一节展示了deque的多种用法。

限长deque提供了类似Unix tail 过滤功能

def tail(filename, n=10):

'Return the last n lines of a file'

with open(filename) as f:

return deque(f, n)

另一个用法是维护一个近期添加元素的序列，通过从右边添加和从左边弹出

def moving_average(iterable, n=3):

# moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0

# https://en.wikipedia.org/wiki/Moving_average

it = iter(iterable)

d = deque(itertools.islice(it, n-1))

d.appendleft(0)

s = sum(d)

for elem in it:

s += elem - d.popleft()

d.append(elem)

yield s / n

一个轮询调度器可以通过在 deque 中放入迭代器来实现。值从当前迭代器的位置0被取出并暂存(yield)。如果这个迭代器消耗完毕，就用 popleft() 将其从对列中移去；否则，就通过 rotate() 将它移到队列的末尾

def roundrobin(*iterables):

"roundrobin('ABC', 'D', 'EF') --> A D E B F C"

iterators = deque(map(iter, iterables))

while iterators:

try:

while True:

yield next(iterators[0])

iterators.rotate(-1)

except StopIteration:

# Remove an exhausted iterator.

iterators.popleft()

rotate() 方法提供了一种方式来实现 deque 切片和删除。例如，一个纯的Python del d[n] 实现依赖于 rotate() 来定位要弹出的元素

def delete_nth(d, n):

d.rotate(-n)

d.popleft()

d.rotate(n)

要实现 deque 切片，使用一个类似的方法，应用 rotate() 将目标元素放到左边。通过 popleft() 移去老的条目（entries），通过 extend() 添加新的条目，然后反向 rotate。这个方法可以最小代价实现命令式的栈操作，诸如 dup, drop, swap, over, pick, rot, 和 roll 。

defaultdict 对象¶

class collections.defaultdict(default_factory=None, /[, ...])¶

返回一个新的类似字典的对象。 defaultdict 是内置 dict 类的子类。它重写了一个方法并添加了一个可写的实例变量。其余的功能与 dict 类相同因而不在此文档中写明。

本对象包含一个名为 default_factory 的属性，构造时，第一个参数用于为该属性提供初始值，默认为 None。所有其他参数（包括关键字参数）都相当于传递给 dict 的构造函数。

defaultdict 对象除了支持标准 dict 的操作，还支持以下方法作为扩展：

__missing__(key)¶

如果 default_factory 属性为 None，则调用本方法会抛出 KeyError 异常，附带参数 key。

如果 default_factory 不为 None，则它会被（不带参数地）调用来为 key 提供一个默认值，这个值和 key 作为一对键值对被插入到字典中，并作为本方法的返回值返回。

如果调用 default_factory 时抛出了异常，这个异常会原封不动地向外层传递。

当请求的键未找到时本方法会被 dict 类的 __getitem__() 方法调用；它返回或引发的任何对象都会被 __getitem__() 返回或引发。

请注意除了 __getitem__() 之外 __missing__() 不会被调用进行任何操作。这意味着 get() 会像普通字典一样返回 None 作为默认值而不是使用 default_factory。

defaultdict 对象支持以下实例变量：

default_factory¶

本属性由 __missing__() 方法来调用。如果构造对象时提供了第一个参数，则本属性会被初始化成那个参数，如果未提供第一个参数，则本属性为 None。

在 3.9 版本发生变更: 增加了合并 (|) 与更新 (|=) 运算符，相关说明见 PEP 584。

defaultdict 例子¶

使用 list 作为 default_factory，很轻松地将（键-值对组成的）序列转换为（键-列表组成的）字典：

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

>>> d = defaultdict(list)

>>> for k, v in s:

... d[k].append(v)

...

>>> sorted(d.items())

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

当每个键第一次遇见时，它还没有在字典里面，所以自动创建该条目，即调用 default_factory 方法，返回一个空的 list。 list.append() 操作添加值到这个新的列表里。当再次存取该键时，就正常操作，list.append() 添加另一个值到列表中。这个计数比它的等价方法 dict.setdefault() 要快速和简单：

>>> d = {}

>>> for k, v in s:

... d.setdefault(k, []).append(v)

...

>>> sorted(d.items())

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

设置 default_factory 为 int，使 defaultdict 用于计数（类似其他语言中的 bag 或 multiset）：

>>> s = 'mississippi'

>>> d = defaultdict(int)

>>> for k in s:

... d[k] += 1

...

>>> sorted(d.items())

[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

当一个字母首次遇到时，它会查询失败，则 default_factory 会调用 int() 来提供一个整数 0 作为默认值。后续的自增操作建立起对每个字母的计数。

函数 int() 总是返回 0，这是常数函数的特殊情况。一个更快和灵活的方法是使用 lambda 函数，可以提供任何常量值（不只是0）：

>>> def constant_factory(value):

... return lambda: value

...

>>> d = defaultdict(constant_factory(''))

>>> d.update(name='John', action='ran')

>>> '%(name)s %(action)s to %(object)s' % d

'John ran to '

设置 default_factory 为 set 使 defaultdict 用于构建 set 集合：

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]

>>> d = defaultdict(set)

>>> for k, v in s:

... d[k].add(v)

...

>>> sorted(d.items())

[('blue', {2, 4}), ('red', {1, 3})]

namedtuple() 命名元组的工厂函数¶

命名元组赋予每个位置一个含义，提供可读性和自文档性。它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)¶

返回一个新的元组子类，名为 typename 。这个新的子类用于创建类元组的对象，可以通过字段名来获取属性值，同样也可以通过索引和迭代获取值。子类实例同样有文档字符串（类名和字段名）另外一个有用的 __repr__() 方法，以 name=value 格式列明了元组内容。

field_names 是一个像 [‘x’, ‘y’] 一样的字符串序列。另外 field_names 可以是一个纯字符串，用空白或逗号分隔开元素名，比如 'x y' 或者 'x, y' 。

任何有效的Python 标识符都可以作为字段名，除了下划线开头的那些。有效标识符由字母，数字，下划线组成，但首字母不能是数字或下划线，另外不能是关键词 keyword 比如 class, for, return, global, pass, 或 raise 。

如果 rename 为真，无效字段名会自动转换成位置名。比如 ['abc', 'def', 'ghi', 'abc'] 转换成 ['abc', '_1', 'ghi', '_3'] ，消除关键词 def 和重复字段名 abc 。

defaults 可以为 None 或者是一个默认值的 iterable 。如果一个默认值域必须跟其他没有默认值的域在一起出现，defaults 就应用到最右边的参数。比如如果域名 ['x', 'y', 'z'] 和默认值 (1, 2) ，那么 x 就必须指定一个参数值，y 默认值 1 ， z 默认值 2 。

如果 module 值有定义，命名元组的 __module__ 属性值就被设置。

具名元组实例毋需字典来保存每个实例的不同属性，所以它们轻量，占用的内存和普通元组一样。

要支持封存操作，应当将命名元组类赋值给一个匹配 typename 的变量。

在 3.1 版本发生变更: 添加了对 rename 的支持。

在 3.6 版本发生变更: verbose 和 rename 参数成为仅限关键字参数.

在 3.6 版本发生变更: 添加了 module 参数。

在 3.7 版本发生变更: 移除了 verbose 形参和 _source 属性。

在 3.7 版本发生变更: 添加了 defaults 参数和 _field_defaults 属性。

>>> # Basic example

>>> Point = namedtuple('Point', ['x', 'y'])

>>> p = Point(11, y=22) # instantiate with positional or keyword arguments

>>> p[0] + p[1] # indexable like the plain tuple (11, 22)

>>> x, y = p # unpack like a regular tuple

>>> x, y

(11, 22)

>>> p.x + p.y # fields also accessible by name

>>> p # readable __repr__ with a name=value style

Point(x=11, y=22)

命名元组尤其有用于赋值 csv sqlite3 模块返回的元组

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv

for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):

print(emp.name, emp.title)

import sqlite3

conn = sqlite3.connect('/companydata')

cursor = conn.cursor()

cursor.execute('SELECT name, age, title, department, paygrade FROM employees')

for emp in map(EmployeeRecord._make, cursor.fetchall()):

print(emp.name, emp.title)

除了继承元组的方法，命名元组还支持三个额外的方法和两个属性。为了防止字段名冲突，方法和属性以下划线开始。

classmethod somenamedtuple._make(iterable)¶

类方法从存在的序列或迭代实例创建一个新实例。

>>> t = [11, 22]

>>> Point._make(t)

Point(x=11, y=22)

somenamedtuple._asdict()¶

返回一个新的 dict ，它将字段名称映射到它们对应的值：

>>> p = Point(x=11, y=22)

>>> p._asdict()

{'x': 11, 'y': 22}

在 3.1 版本发生变更: 返回一个 OrderedDict 而不是 dict 。

在 3.8 版本发生变更: 返回一个常规 dict 而不是 OrderedDict。因为自 Python 3.7 起，常规字典已经保证有序。如果需要 OrderedDict 的额外特性，推荐的解决方案是将结果转换为需要的类型: OrderedDict(nt._asdict())。

somenamedtuple._replace(**kwargs)¶

返回一个新的命名元组实例，并将指定域替换为新的值

>>> p = Point(x=11, y=22)

>>> p._replace(x=33)

Point(x=33, y=22)

>>> for partnum, record in inventory.items():

... inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())

somenamedtuple._fields¶

字符串元组列出了字段名。用于提醒和从现有元组创建一个新的命名元组类型。

>>> p._fields # view the field names

('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')

>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)

>>> Pixel(11, 22, 128, 255, 0)

Pixel(x=11, y=22, red=128, green=255, blue=0)

somenamedtuple._field_defaults¶

字典将字段名称映射到默认值。

>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])

>>> Account._field_defaults

{'balance': 0}

>>> Account('premium')

Account(type='premium', balance=0)

要获取这个名字域的值，使用 getattr() 函数 :

>>> getattr(p, 'x')

转换一个字典到命名元组，使用 ** 两星操作符 (所述如解包实参列表):

>>> d = {'x': 11, 'y': 22}

>>> Point(**d)

Point(x=11, y=22)

因为一个命名元组是一个正常的Python类，它可以很容易的通过子类更改功能。这里是如何添加一个计算域和定宽输出打印格式:

>>> class Point(namedtuple('Point', ['x', 'y'])):

... __slots__ = ()

... @property

... def hypot(self):

... return (self.x ** 2 + self.y ** 2) ** 0.5

... def __str__(self):

... return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):

... print(p)

Point: x= 3.000 y= 4.000 hypot= 5.000

Point: x=14.000 y= 0.714 hypot=14.018

上面的子类设置 __slots__ 为一个空元组。通过阻止创建实例字典保持了较低的内存开销。

子类化对于添加和存储新的名字域是无效的。应当通过 _fields 创建一个新的命名元组来实现它:

>>> Point3D = namedtuple('Point3D', Point._fields + ('z',))

文档字符串可以自定义，通过直接赋值给 __doc__ 属性:

>>> Book = namedtuple('Book', ['id', 'title', 'authors'])

>>> Book.__doc__ += ': Hardcover book in active collection'

>>> Book.id.__doc__ = '13-digit ISBN'

>>> Book.title.__doc__ = 'Title of first printing'

>>> Book.authors.__doc__ = 'List of authors sorted by last name'

在 3.5 版本发生变更: 文档字符串属性变成可写。

参见

请参阅 typing.NamedTuple ，以获取为命名元组添加类型提示的方法。它还使用 class 关键字提供了一种优雅的符号:

class Component(NamedTuple):

part_number: int

weight: float

description: Optional[str] = None

对于以字典为底层的可变域名，参考 types.SimpleNamespace() 。

dataclasses 模块提供了一个装饰器和一些函数，用于自动将生成的特殊方法添加到用户定义的类中。

OrderedDict 对象¶

有序词典就像常规词典一样，但有一些与排序操作相关的额外功能。由于内置的 dict 类获得了记住插入顺序的能力（在 Python 3.7 中保证了这种新行为），它们变得不那么重要了。

一些与 dict 的不同仍然存在：

常规的 dict 被设计为非常擅长映射操作。跟踪插入顺序是次要的。

OrderedDict 旨在擅长重新排序操作。空间效率、迭代速度和更新操作的性能是次要的。

OrderedDict 算法能比 dict 更好地处理频繁的重排序操作。如下面的例程所示，这使得它更适用于实现各种 LRU 缓存。

对于 OrderedDict ，相等操作检查匹配顺序。

常规的 dict 可以使用 p == q and all(k1 == k2 for k1, k2 in zip(p, q)) 进行模拟顺序相等性测试。

OrderedDict 类的 popitem() 方法有不同的签名。它接受一个可选参数来指定弹出哪个元素。

常规的 dict 可以使用 d.popitem() 模拟 OrderedDict 的 od.popitem(last=True)，其保证会返回最右边（最后）的项。

常规的 dict 可以通过 (k := next(iter(d)), d.pop(k)) 来模拟 OrderedDict 的 od.popitem(last=False)，它将返回并移除最左边（开头）的条目，如果条目存在的话。

OrderedDict 类有一个 move_to_end() 方法，可以有效地将元素移动到任一端。

常规的 dict 可以通过 d[k] = d.pop(k) 来模拟 OrderedDict 的 od.move_to_end(k, last=True)，它将把键及其所关联的值移到最右边（末尾）的位置。

常规的 dict 没有 OrderedDict 的 od.move_to_end(k, last=False) 的高效等价物，它会把键及其所关联的值移到最左边（开头）的位置。

Python 3.8之前， dict 缺少 __reversed__() 方法。

class collections.OrderedDict([items])¶

返回一个 dict 子类的实例，它具有专门用于重新排列字典顺序的方法。

在 3.1 版本加入.

popitem(last=True)¶

有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。如果 last 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回键值对。

move_to_end(key, last=True)¶

将一个现有的 key 移到序字典的任一端。如果 last 为真值（默认）则将条目移到右端，或者如果 last 为假值则将条目移到开头。如果 key 不存在则会引发 KeyError:

>>> d = OrderedDict.fromkeys('abcde')

>>> d.move_to_end('b')

>>> ''.join(d)

'acdeb'

>>> d.move_to_end('b', last=False)

>>> ''.join(d)

'bacde'

在 3.2 版本加入.

相对于通常的映射方法，有序字典还另外提供了逆序迭代的支持，通过 reversed() 。

OrderedDict 之间的相等测试是顺序敏感的，实现为 list(od1.items())==list(od2.items()) 。 OrderedDict 对象和其他的 Mapping 的相等测试，是顺序敏感的字典测试。这允许 OrderedDict 替换为任何字典可以使用的场所。

在 3.5 版本发生变更: OrderedDict 的项(item)，键(key)和值(value) 视图现在支持逆序迭代，通过 reversed() 。

在 3.6 版本发生变更: PEP 468 赞成将关键词参数的顺序保留，通过传递给 OrderedDict 构造器和它的 update() 方法。

在 3.9 版本发生变更: 增加了合并 (|) 与更新 (|=) 运算符，相关说明见 PEP 584。

OrderedDict 例子和用法¶

创建记住键值最后插入顺序的有序字典变体很简单。如果新条目覆盖现有条目，则原始插入位置将更改并移至末尾:

class LastUpdatedOrderedDict(OrderedDict):

'Store items in the order the keys were last added'

def __setitem__(self, key, value):

super().__setitem__(key, value)

self.move_to_end(key)

一个 OrderedDict 对于实现 functools.lru_cache() 的变体也很有用:

from collections import OrderedDict

from time import time

class TimeBoundedLRU:

"LRU Cache that invalidates and refreshes old entries."

def __init__(self, func, maxsize=128, maxage=30):

self.cache = OrderedDict() # { args : (timestamp, result)}

self.func = func

self.maxsize = maxsize

self.maxage = maxage

def __call__(self, *args):

if args in self.cache:

self.cache.move_to_end(args)

timestamp, result = self.cache[args]

if time() - timestamp <= self.maxage:

return result

result = self.func(*args)

self.cache[args] = time(), result

if len(self.cache) > self.maxsize:

self.cache.popitem(0)

return result

class MultiHitLRUCache:

""" LRU cache that defers caching a result until

it has been requested multiple times.

To avoid flushing the LRU cache with one-time requests,

we don't cache until a request has been made more than once.

"""

def __init__(self, func, maxsize=128, maxrequests=4096, cache_after=1):

self.requests = OrderedDict() # { uncached_key : request_count }

self.cache = OrderedDict() # { cached_key : function_result }

self.func = func

self.maxrequests = maxrequests # max number of uncached requests

self.maxsize = maxsize # max number of stored return values

self.cache_after = cache_after

def __call__(self, *args):

if args in self.cache:

self.cache.move_to_end(args)

return self.cache[args]

result = self.func(*args)

self.requests[args] = self.requests.get(args, 0) + 1

if self.requests[args] <= self.cache_after:

self.requests.move_to_end(args)

if len(self.requests) > self.maxrequests:

self.requests.popitem(0)

else:

self.requests.pop(args, None)

self.cache[args] = result

if len(self.cache) > self.maxsize:

self.cache.popitem(0)

return result

UserDict 对象¶

UserDict 类是用作字典对象的外包装。对这个类的需求已部分由直接创建 dict 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的字典可以作为属性来访问。

class collections.UserDict([initialdata])¶

模拟字典的类。这个实例的内容保存在一个常规字典中，它可以通过 UserDict 实例的 data 属性来访问。如果提供了 initialdata，则 data 会用其内容来初始化；请注意对 initialdata 的引用将不会被保留，以允许它被用于其他目的。

UserDict 实例提供了以下属性作为扩展方法和操作的支持:

data¶

一个真实的字典，用于保存 UserDict 类的内容。

UserList 对象¶

这个类封装了列表对象。它是一个有用的基础类，对于你想自定义的类似列表的类，可以继承和覆盖现有的方法，也可以添加新的方法。这样我们可以对列表添加新的行为。

对这个类的需求已部分由直接创建 list 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的列表可以作为属性来访问。

class collections.UserList([list])¶

模拟一个列表。这个实例的内容被保存为一个正常列表，通过 UserList 的 data 属性存取。实例内容被初始化为一个 list 的copy，默认为 [] 空列表。 list 可以是迭代对象，比如一个Python列表，或者一个 UserList 对象。

UserList 提供了以下属性作为可变序列的方法和操作的扩展:

data¶

一个 list 对象用于存储 UserList 的内容。

子类化的要求: UserList 的子类需要提供一个构造器，可以无参数调用，或者一个参数调用。返回一个新序列的列表操作需要创建一个实现类的实例。它假定了构造器可以以一个参数进行调用，这个参数是一个序列对象，作为数据源。

如果一个分离的类不希望依照这个需求，所有的特殊方法就必须重写；请参照源代码进行修改。

UserString 对象¶

UserString 类是用作字符串对象的外包装。对这个类的需求已部分由直接创建 str 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的字符串可以作为属性来访问。

class collections.UserString(seq)¶

模拟一个字符串对象。这个实例对象的内容保存为一个正常字符串，通过 UserString 的 data 属性存取。实例内容初始化设置为 seq 的copy。seq 参数可以是任何可通过内建 str() 函数转换为字符串的对象。

UserString 提供了以下属性作为字符串方法和操作的额外支持：

data¶

一个真正的 str 对象用来存放 UserString 类的内容。

在 3.5 版本发生变更: 新方法 __getnewargs__, __rmod__, casefold, format_map, isprintable, 和 maketrans。

collections --- 容器数据类型

ChainMap 对象

ChainMap 例子和方法

Counter 对象

deque 对象

deque 用法

defaultdict 对象

defaultdict 例子

namedtuple() 命名元组的工厂函数

OrderedDict 对象

OrderedDict 例子和用法

UserDict 对象

UserList 对象

UserString 对象

上一主题

calendar --- 日历相关函数

下一主题

collections.abc --- 容器的抽象基类

当前页面

报告 Bug

显示源码

导航

索引

模块 |

下一页 |

上一页 |

Python »

3.12.2 Documentation »

Python 标准库 »

数据类型 »

collections --- 容器数据类型

Theme

Auto

Light

Dark

This page is licensed under the Python Software Foundation License Version 2.

Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.

See History and License for more information.

The Python Software Foundation is a non-profit corporation.

Please donate.

最后更新于 Mar 07, 2024 (19:23 UTC).

Found a bug?

由 Sphinx 7.2.6创建。

python标准库: collections介绍 - 知乎

python标准库: collections介绍 - 知乎首发于python 库切换模式写文章登录/注册python标准库: collections介绍寒彦最近准备整理一下Python内容collections模块包含了除list、dict、和tuple之外的容器数据类型，如counter、defaultdict、deque、namedtuple、orderdict，下面将一一介绍。1. CounterCounter 支持三种形式的初始化。它的构造函数可以调用序列，一个字典包含密钥和计数，或使用关键字参数映射的字符串名称。import collections

print(collections.Counter(['a', 'b', 'c', 'a', 'b', 'b']))

print(collections.Counter({'a': 2, 'b': 3, 'c': 1}))

print(collections.Counter(a=2, b=3, c=1))输出:Counter({'b': 3, 'a': 2, 'c': 1})

Counter({'b': 3, 'a': 2, 'c': 1})

Counter({'b': 3, 'a': 2, 'c': 1})空的Counter容器可以无参数构造，并采用update()方法进行更新import collections

c = collections.Counter()

print ('Initial :', c)

c.update('abcdaab')

print ('Sequence:', c)

c.update({'a':1, 'd':5})

print ('Dict :', c)输出:Initial : Counter()

Sequence: Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})

Dict : Counter({'d': 6, 'a': 4, 'b': 2, 'c': 1})当一个Counter被构造成功，它的值可以采用字典进行访问import collections

c = collections.Counter('abcdaab')

for letter in 'abcde':

print ('%s : %d' % (letter, c[letter]))输出:a : 3

b : 2

c : 1

d : 1

e : 0elements()方法可以返回一个包含所有Counter数据的迭代器import collections

c = collections.Counter('extremely')

c['z'] = 0

print(c)

print (list(c.elements()))输出:Counter({'e': 3, 'x': 1, 't': 1, 'r': 1, 'm': 1, 'l': 1, 'y': 1, 'z': 0})

['e', 'e', 'e', 'x', 't', 'r', 'm', 'l', 'y']most_common()返回前n个最多的数据import collections

c=collections.Counter('aassdddffff')

for letter, count in c.most_common(2):

print ('%s: %d' % (letter, count))输出:f: 4

d: 3Counter实例支持聚合结果的算术和集合操作。import collections

c1 = collections.Counter(['a', 'b', 'c', 'a', 'b', 'b'])

c2 = collections.Counter('alphabet')

print ('C1:', c1)

print ('C2:', c2)

print ('\nCombined counts:')

print (c1 + c2)

print ('\nSubtraction:')

print (c1 - c2)

print ('\nIntersection (taking positive minimums):')

print (c1 & c2)

print ('\nUnion (taking maximums):')

print (c1 | c2)输出:C1: Counter({'b': 3, 'a': 2, 'c': 1})

C2: Counter({'a': 2, 'l': 1, 'p': 1, 'h': 1, 'b': 1, 'e': 1, 't': 1})

Combined counts:

Counter({'a': 4, 'b': 4, 'c': 1, 'l': 1, 'p': 1, 'h': 1, 'e': 1, 't': 1})

Subtraction:

Counter({'b': 2, 'c': 1})

Intersection (taking positive minimums):

Counter({'a': 2, 'b': 1})

Union (taking maximums):

Counter({'b': 3, 'a': 2, 'c': 1, 'l': 1, 'p': 1, 'h': 1, 'e': 1, 't': 1})2. defaultdict标准字典包括setdefault方法()获取一个值，如果值不存在，建立一个默认。相比之下, defaultdict 允许调用者在初始化时预先设置默认值。import collections

def default_factory():

return 'default value'

d = collections.defaultdict(default_factory, foo='bar')

print ('d:', d)

print ('foo =>', d['foo'])

print ('x =>', d['x'])输出:d: defaultdict(, {'foo': 'bar'})

foo => bar

x => default value3. Deque双端队列，支持从两端添加和删除元素。更常用的栈和队列是退化形式的双端队列，仅限于一端在输入和输出。import collections

d = collections.deque('abcdefg')

print ('Deque:', d)

print ('Length:', len(d))

print ('Left end:', d[0])

print ('Right end:', d[-1])

d.remove('c')

print ('remove(c):', d)输出:Deque: deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])

Length: 7

Left end: a

Right end: g

remove(c): deque(['a', 'b', 'd', 'e', 'f', 'g'])双端队列从左右两端插入数据import collections

# 右端插入

d = collections.deque()

d.extend('abcdefg')

print ('extend :', d)

d.append('h')

print ('append :', d)

# 左端插入

d = collections.deque()

d.extendleft('abcdefg')

print ('extendleft:', d)

d.appendleft('h')

print ('appendleft:', d)输出:extend : deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])

append : deque(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

extendleft: deque(['g', 'f', 'e', 'd', 'c', 'b', 'a'])

appendleft: deque(['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a'])类似地，双端队列的元素可以从两端获取。import collections

print ('From the right:')

d = collections.deque('abcdefg')

while True:

try:

print(d.pop())

except IndexError:

break

print ('\nFrom the left:')

d = collections.deque('abcdefg')

while True:

try:

print(d.popleft())

except IndexError:

break输出:From the right:

From the left:

g由于双端队列是线程安全的，在单独的线程中内容甚至可以从两端同时消费。import collections

import threading

import time

candle = collections.deque(range(11))

def burn(direction, nextSource):

while True:

try:

next = nextSource()

except IndexError:

break

else:

print ('%8s: %s' % (direction, next))

time.sleep(0.1)

print ('%8s done' % direction)

return

left = threading.Thread(target=burn, args=('Left', candle.popleft))

right = threading.Thread(target=burn, args=('Right', candle.pop))

left.start()

right.start()

left.join()

right.join()输出:Left: 0

Right: 10

Left: 1

Right: 9

Left: 2

Right: 8

Left: 3

Right: 7

Left: 4

Right: 6

Left: 5

Right done

Left done队列的另一个有用的功能是在任意方向旋转，通俗来讲就是队列的左移右移import collections

d = collections.deque(range(10))

print ('Normal :', d)

d = collections.deque(range(10))

d.rotate(2)

print ('Right rotation:', d)

d = collections.deque(range(10))

d.rotate(-2)

print ('Left rotation :', d)输出:Normal : deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Right rotation: deque([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])

Left rotation : deque([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])4. namedtuple标准的元组使用数值索引来访问其成员bob = ('Bob', 30, 'male')

print('Representation:', bob)

jane = ('Jane', 29, 'female')

print('\nField by index:', jane[0])

print('\nFields by index:')

for p in [bob, jane]:

print('%s is a %d year old %s' % p)输出:Representation: ('Bob', 30, 'male')

Field by index: Jane

Fields by index:

Bob is a 30 year old male

Jane is a 29 year old female记住每个索引对应的值是很容易出错的，尤其是在元组有多个元素的情况下。namedtuple为每个成员分配了名字。import collections

Person = collections.namedtuple('Person', 'name age gender')

print('Type of Person:', type(Person))

bob = Person(name='Bob', age=30, gender='male')

print('\nRepresentation:', bob)

jane = Person(name='Jane', age=29, gender='female')

print('\nField by name:', jane.name)

print('\nFields by index:')

for p in [bob, jane]:

print('%s is a %d year old %s' % p)输出:Type of Person:

Representation: Person(name='Bob', age=30, gender='male')

Field by name: Jane

Fields by index:

Bob is a 30 year old male

Jane is a 29 year old female字段名称解析，无效值会导致ValueErrorimport collections

try:

collections.namedtuple('Person', 'name class age gender')

except ValueError as err:

print(err)

try:

collections.namedtuple('Person', 'name age gender age')

except ValueError as err:

print(err)输出:Type names and field names cannot be a keyword: 'class'

Encountered duplicate field name: 'age'5. OrderedDictOrderedDict是字典子类，记得其内容被添加的顺序目前字典支持有序import collections

print ('Regular dictionary:')

d = {}

d['a'] = 'A'

d['b'] = 'B'

d['c'] = 'C'

d['d'] = 'D'

d['e'] = 'E'

for k, v in d.items():

print( k, v)

print ('\nOrderedDict:')

d = collections.OrderedDict()

d['a'] = 'A'

d['b'] = 'B'

d['c'] = 'C'

d['d'] = 'D'

d['e'] = 'E'

for k, v in d.items():

print (k, v)输出:Regular dictionary:

a A

b B

c C

d D

e E

OrderedDict:

a A

b B

c C

d D

e E发布于 2020-09-15 09:05PythonPython 标准库Python 库赞同 5添加评论分享喜欢收藏申请转载文章被以下专栏收录pytho

collections - 廖雪峰的官方网站

Index

廖雪峰的官方网站

Blog

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Profile

Passkey

Sign Out

English

简体中文

Index

Python教程

Python简介

安装Python

Python解释器

第一个Python程序

使用文本编辑器

Python代码运行助手

输入和输出

Python基础

数据类型和变量

字符串和编码

使用list和tuple

条件判断

模式匹配

循环

使用dict和set

函数

调用函数

定义函数

函数的参数

递归函数

高级特性

切片

迭代

列表生成式

生成器

迭代器

函数式编程

高阶函数

map/reduce

filter

sorted

返回函数

匿名函数

装饰器

偏函数

模块

使用模块

安装第三方模块

面向对象编程

类和实例

访问限制

继承和多态

获取对象信息

实例属性和类属性

面向对象高级编程

使用__slots__

使用@property

多重继承

定制类

使用枚举类

使用元类

错误、调试和测试

错误处理

调试

单元测试

文档测试

IO编程

文件读写

StringIO和BytesIO

操作文件和目录

序列化

进程和线程

多进程

多线程

ThreadLocal

进程 vs. 线程

分布式进程

正则表达式

常用内建模块

datetime

collections

argparse

base64

struct

hashlib

hmac

itertools

contextlib

urllib

XML

HTMLParser

常用第三方模块

Pillow

requests

chardet

psutil

venv

图形界面

海龟绘图

网络编程

TCP/IP简介

TCP编程

UDP编程

电子邮件

SMTP发送邮件

POP3收取邮件

访问数据库

使用SQLite

使用MySQL

使用SQLAlchemy

Web开发

HTTP协议简介

HTML简介

WSGI接口

使用Web框架

使用模板

异步IO

协程

asyncio

async/await

aiohttp

使用MicroPython

搭建开发环境

控制小车

遥控小车

遥控转向

实战

Day 1 - 搭建开发环境

Day 2 - 编写Web App骨架

Day 3 - 编写ORM

Day 4 - 编写Model

Day 5 - 编写Web框架

Day 6 - 编写配置文件

Day 7 - 编写MVC

Day 8 - 构建前端

Day 9 - 编写API

Day 10 - 用户注册和登录

Day 11 - 编写日志创建页

Day 12 - 编写日志列表页

Day 13 - 提升开发效率

Day 14 - 完成Web App

Day 15 - 部署Web App

Day 16 - 编写移动App

FAQ

期末总结

关注公众号不定期领红包：

加入知识星球社群：

关注微博获取实时动态：

collections

Last updated: ...

Edit

collections是Python内建的一个集合模块，提供了许多有用的集合类。

namedtuple

我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：

>>> p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

定义一个class又小题大做了，这时，namedtuple就派上了用场：

>>> from collections import namedtuple

>>> Point = namedtuple('Point', ['x', 'y'])

>>> p = Point(1, 2)

>>> p.x

>>> p.y

namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。

这样一来，我们用namedtuple可以很方便地定义一种数据类型，它具备tuple的不变性，又可以根据属性来引用，使用十分方便。

可以验证创建的Point对象是tuple的一种子类：

>>> isinstance(p, Point)

True

>>> isinstance(p, tuple)

True

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

# namedtuple('名称', [属性list]):

Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

>>> from collections import deque

>>> q = deque(['a', 'b', 'c'])

>>> q.append('x')

>>> q.appendleft('y')

>>> q

deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

defaultdict

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict

>>> dd = defaultdict(lambda: 'N/A')

>>> dd['key1'] = 'abc'

>>> dd['key1'] # key1存在

'abc'

>>> dd['key2'] # key2不存在，返回默认值

'N/A'

注意默认值是调用函数返回的，而函数在创建defaultdict对象时传入。

除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的。

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

>>> from collections import OrderedDict

>>> d = dict([('a', 1), ('b', 2), ('c', 3)])

>>> d # dict的Key是无序的

{'a': 1, 'c': 3, 'b': 2}

>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

>>> od # OrderedDict的Key是有序的

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od = OrderedDict()

>>> od['z'] = 1

>>> od['y'] = 2

>>> od['x'] = 3

>>> list(od.keys()) # 按照插入的Key的顺序返回

['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)

ChainMap

ChainMap可以把一组dict串起来并组成一个逻辑上的dict。ChainMap本身也是一个dict，但是查找的时候，会按照顺序在内部的dict依次查找。

什么时候使用ChainMap最合适？举个例子：应用程序往往都需要传入参数，参数可以通过命令行传入，可以通过环境变量传入，还可以有默认参数。我们可以用ChainMap实现参数的优先级查找，即先查命令行参数，如果没有传入，再查环境变量，如果没有，就使用默认参数。

下面的代码演示了如何查找user和color这两个参数：

from collections import ChainMap

import os, argparse

# 构造缺省参数:

defaults = {

'color': 'red',

'user': 'guest'

}

# 构造命令行参数:

parser = argparse.ArgumentParser()

parser.add_argument('-u', '--user')

parser.add_argument('-c', '--color')

namespace = parser.parse_args()

command_line_args = { k: v for k, v in vars(namespace).items() if v }

# 组合成ChainMap:

combined = ChainMap(command_line_args, os.environ, defaults)

# 打印参数:

print('color=%s' % combined['color'])

print('user=%s' % combined['user'])

没有任何参数时，打印出默认参数：

$ python3 use_chainmap.py

color=red

user=guest

当传入命令行参数时，优先使用命令行参数：

$ python3 use_chainmap.py -u bob

color=red

user=bob

同时传入命令行参数和环境变量，命令行参数的优先级较高：

$ user=admin color=green python3 use_chainmap.py -u bob

color=green

user=bob

Counter

Counter是一个简单的计数器，例如，统计字符出现的个数：

>>> from collections import Counter

>>> c = Counter()

>>> for ch in 'programming':

... c[ch] = c[ch] + 1

...

>>> c

Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

>>> c.update('hello') # 也可以一次性update

>>> c

Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})

Counter实际上也是dict的一个子类，上面的结果可以看出每个字符出现的次数。

小结

collections模块提供了一些有用的集合类，可以根据需要选用。

参考源码

use_collections.py

Comments

Make a comment

make a comment

Index

Python教程

Python简介

安装Python

Python解释器

第一个Python程序

使用文本编辑器

Python代码运行助手

输入和输出

Python基础

数据类型和变量

字符串和编码

使用list和tuple

条件判断

模式匹配

循环

使用dict和set

函数

调用函数

定义函数

函数的参数

递归函数

高级特性

切片

迭代

列表生成式

生成器

迭代器

函数式编程

高阶函数

map/reduce

filter

sorted

返回函数

匿名函数

装饰器

偏函数

模块

使用模块

安装第三方模块

面向对象编程

类和实例

访问限制

继承和多态

获取对象信息

实例属性和类属性

面向对象高级编程

使用__slots__

使用@property

多重继承

定制类

使用枚举类

使用元类

错误、调试和测试

错误处理

调试

单元测试

文档测试

IO编程

文件读写

StringIO和BytesIO

操作文件和目录

序列化

进程和线程

多进程

多线程

ThreadLocal

进程 vs. 线程

分布式进程

正则表达式

常用内建模块

datetime

collections

argparse

base64

struct

hashlib

hmac

itertools

contextlib

urllib

XML

HTMLParser

常用第三方模块

Pillow

requests

chardet

psutil

venv

图形界面

海龟绘图

网络编程

TCP/IP简介

TCP编程

UDP编程

电子邮件

SMTP发送邮件

POP3收取邮件

访问数据库

使用SQLite

使用MySQL

使用SQLAlchemy

Web开发

HTTP协议简介

HTML简介

WSGI接口

使用Web框架

使用模板

异步IO

协程

asyncio

async/await

aiohttp

使用MicroPython

搭建开发环境

控制小车

遥控小车

遥控转向

实战

Day 1 - 搭建开发环境

Day 2 - 编写Web App骨架

Day 3 - 编写ORM

Day 4 - 编写Model

Day 5 - 编写Web框架

Day 6 - 编写配置文件

Day 7 - 编写MVC

Day 8 - 构建前端

Day 9 - 编写API

Day 10 - 用户注册和登录

Day 11 - 编写日志创建页

Day 12 - 编写日志列表页

Day 13 - 提升开发效率

Day 14 - 完成Web App

Day 15 - 部署Web App

Day 16 - 编写移动App

FAQ

期末总结

廖雪峰的官方网站

Feedback

License

如何在 Python 中使用 collections 模块？ - 知乎

如何在 Python 中使用 collections 模块？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册Python计算机技术Python 入门Python 开发Python教程如何在 Python 中使用 collections 模块？关注者8被浏览2,581关注问题写回答邀请回答好问题添加评论分享5 个回答默认排序pythontip热爱生活，自由编码，创造美好世界关注 Python 中的 collections 模块实现了专门的容器数据类型，为 Python 的通用内置容器: dict、list、set 和 tuple 提供了替代方案。主要包括以下工具：namedtuple: 创建具有命名字段的 tuple 子类OrderedDict: 创建能够记住添加项目的顺序的 dict 子类Counter: 创建计数器的 dict 子类defaultdict : 创建存在默认值的 dict 子类deque : 创建双端队列的 list 子类在 Python 3 中，其他相关模块：ChainMap, UserDict, UserList, UserString。可在官方文档查看更多信息。Counter 计数counter是一个字典。存储元素字典的键，其计数值作为字典的值。from collections import Counter

a = "aaaaabbbbcccdde"

my_counter = Counter(a)

print(my_counter)

print(my_counter.items())

print(my_counter.keys())

print(my_counter.values())

my_list = [0, 1, 0, 1, 2, 1, 1, 3, 2, 3, 2, 4]

my_counter = Counter(my_list)

print(my_counter)

# 出现次数最多的元素

print(my_counter.most_common(1))

print(my_counter.most_common(3))

print(list(my_counter.elements()))输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

dict_items([('a', 5), ('b', 4), ('c', 3), ('d', 2), ('e', 1)])

dict_keys(['a', 'b', 'c', 'd', 'e'])

dict_values([5, 4, 3, 2, 1])

Counter({1: 4, 2: 3, 0: 2, 3: 2, 4: 1})

[(1, 4)]

[(1, 4), (2, 3), (0, 2)]

[0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4]namedtuple 命名元组namedtuple 是很容易创建的，轻量级的对象类型。它们给每个位置赋予了意义，并让代码更加易读。它们可以在正常的元组使用的地方使用，并且添加了通过名称而不是索引来访问字段的能力。代码：from collections import namedtuple

# 创建一个具有类名为字符串和字段为字符串的 namedtuple

# 字段必须用逗号或空格分隔在给定的字符串中

Point = namedtuple('Point', 'x, y') # 创建一个元组的子类：Point。它的类名为 Point，它的字段为 x 和 y。

pt = Point(1, -4)

print(pt)

print(pt._fields)

print(type(pt))

print(pt.x, pt.y)

Person = namedtuple('Person', 'name, age')

friend = Person(name='Tom', age=25)

print(friend.name, friend.age)结果：Point(x=1, y=-4)

('x', 'y')

1 -4

Tom 25OrderedDict 有序字典 python3.7以后不建议使用它了。因为python的内置dict已经支持顺序了。 OrderedDicts 是一个简单的字典，它记住插入项目的顺序。当迭代一个有序字典时，其项目是按照它们的键被第一次添加的顺序返回。如果新的项目覆盖了现有的项目，则原始插入位置仍然保持不变。它们现在已经不再需要了，因为 dict 类型获得了能够记住插入顺序的能力（从 Python 3.7 开始）。但是还有一些差异仍然存在，例如 OrderedDict 是设计用于重新排序操作的。代码：from collections import OrderedDict

ordinary_dict = {}

ordinary_dict['a'] = 1

ordinary_dict['b'] = 2

ordinary_dict['c'] = 3

ordinary_dict['d'] = 4

ordinary_dict['e'] = 5

# 在 Python 3.7 之前是随机的

print(ordinary_dict)

ordered_dict = OrderedDict()

ordered_dict['a'] = 1

ordered_dict['b'] = 2

ordered_dict['c'] = 3

ordered_dict['d'] = 4

ordered_dict['e'] = 5

print(ordered_dict)

# 一些差异仍然存在，例如 OrderedDict 是设计用于重新排序操作的。

for k, v in ordinary_dict.items():

print(k, v)结果：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])

a 1

b 2

c 3

d 4

e 5defaultdict 带默认值字典defaultdict 是一个容器，它和普通的 dict 容器相似，但它只有在键不存在时才会设置默认值。如果你不使用 defaultdict，你需要检查键是否存在，如果不存在，就设置它为你想要的值。代码：from collections import defaultdict

# 初始化为默认整数值，即 0

d = defaultdict(int)

d['yellow'] = 1

d['blue'] = 2

print(d.items())

print(d['green'])

# 初始化为默认列表值，即空列表

d = defaultdict(list)

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 5)]

for k, v in s:

d[k].append(v)

print(d.items())

print(d['green'])结果：dict_items([('yellow', 1), ('blue', 2)])

dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [5])])

[]deque 双端队列deque 是一个双端队列。它可以用来在两端添加或删除元素。 deque 支持线程安全，内存效率高的在两端添加或删除元素，其执行时间为 O(1)。 deque 是一个更常用的栈和队列的衍生，其输入和输出只能在一端。代码：from collections import deque

d = deque()

# append()：将元素添加到右端

d.append('a')

d.append('b')

print(d)

# appendleft(): 将元素添加到左端

d.appendleft('c')

print(d)

# pop()：从右端删除并返回一个元素

print(d.pop())

print(d)

# popleft(): 从左端删除并返回一个元素

print(d.popleft())

print(d)

# clear(): 清空 deque

d.clear()

print(d)

d = deque(['a', 'b', 'c', 'd'])

# 在右端或左端添加一个序列

d.extend(['e', 'f', 'g'])

d.extendleft(['h', 'i', 'j']) # 注意，'j' 现在在左端的位置

print(d)

# count(x)：返回 x 在 deque 中的个数

print(d.count('h'))

# 将 deque 向右旋转一位

d.rotate(1)

print(d)

# 将 deque 向左旋转两位

d.rotate(-2)

print(d)结果：deque(['a', 'b'])

deque(['c', 'a', 'b'])

deque(['c', 'a'])

deque(['a'])

deque([])

deque(['j', 'i', 'h', 'a', 'b', 'c', 'd', 'e', 'f', 'g'])

deque(['g', 'j', 'i', 'h', 'a', 'b', 'c', 'd', 'e', 'f'])

deque(['i', 'h', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'j'])小节上面分享了神器collections模块的5大常用容器类型:Counter 计数namedtuple 命名元组OrderedDict 有序字典defaultdict 带默认值字典deque 双端队列熟练使用这些容器类型，在某些任务场景下将大幅提升编码效率！如对字符串的字符进行计数等。如果觉得有所收获，欢迎大家点赞、收藏，支持！pythontip 出品，Happy Coding！公众号: 夸克编程发布于 2022-04-01 10:54赞同 10添加评论分享收藏喜欢收起小小张说故事历史人物解说；python编程爱好者关注collections模块是Python的内建模块之一，它实现了特殊的容器数据类型，提供了Python内建的数据类型dict、list、set、和tuple的高效替代选择。一、namedtuplenamedtuple() 函数是一个工厂函数，它返回一个子类，这个子类继承自 tuple 类，并且拥有名字，这个名字就是你传给 namedtuple() 的第一个参数。这个子类的实例就像一个普通的元组，但是还提供了方便的属性访问。namedtuple是一种定义小型和不可变的数据类的简单方法。from collections import namedtuple

# 创建一个namedtuple类型User，并包含name和age两个属性。

User = namedtuple('User', ['name', 'age'])

# 创建一个User对象

user = User(name='user1', age=23)

print(user.name) # 输出：user1

print(user.age) # 输出：23二、dequedeque（双向队列）是一种来自 collections 模块的容器，它提供了从左端和右端高效、快速地添加和删除元素的功能。from collections import deque

# 创建一个deque

d = deque(['a', 'b', 'c'])

# 从右端添加元素

d.append('d') # d现在是deque(['a', 'b', 'c', 'd'])

# 从左端添加元素

d.appendleft('e') # d现在是deque(['e', 'a', 'b', 'c', 'd'])

# 从右端删除元素

d.pop() # 返回 'd', d现在是deque(['e', 'a', 'b', 'c'])

# 从左端删除元素

d.popleft() # 返回 'e', d现在是deque(['a', 'b', 'c'])三、Countercollections模块的Counter类是一个简单的计数器，例如，它可以用来统计字符的个数：from collections import Counter

c = Counter('hello world') # 从一个可迭代对象创建

print(c) # 输出 Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})Counter对象有一个有用的方法most_common(n)，该方法返回计数最多的n个元素的列表，每个元素是一个元组，元组的第一个元素是元素本身，第二个元素是元素的计数。四、defaultdictdefaultdict是dict的一个子类，它接受一个工厂函数作为默认值，当查找的键不存在时，可以实例化一个值作为默认值。from collections import defaultdict

# 使用列表(list)作为default_factory，当键不存在时，返回一个空列表。

dd = defaultdict(list)

# 添加一个键值对

dd['dogs'].append('Rufus')

dd['dogs'].append('Kathrin')

dd['dogs'].append('Mr Sniffles')

print(dd['dogs']) # 输出: ['Rufus', 'Kathrin', 'Mr Sniffles']五、OrderedDictOrderedDict是dict的一个子类，它记住了元素插入的顺序。在Python 3.7之前，普通的dict并不保证键值对的顺序，而OrderedDict则按照插入的顺序排列元素。从Python 3.7开始，dict也会保持插入顺序，但是OrderedDict仍然有它的特性，如重新排列字典的顺序等。from collections import OrderedDict

d = OrderedDict()

d['first'] = 1

d['second'] = 2

d['third'] = 3

d['last'] = 4

# 输出 "first 1", "second 2", "third 3", "last 4"

for key in d:

print(key, d[key])六、结论collections模块中还包含有其他有用的工具，如ChainMap、UserDict、UserList等等，这些都是非常实用的集合类。使用和理解这些数据结构可以让我们在编程中更加得心应手，代码更加高效和清晰。上述这些是 collections 模块中最常用的一些数据结构，理解和熟练使用这些工具，可以极大提高我们编程的效率。希望这篇文章能帮助你深入理解Python中的collections模块，能够更好的使用Python进行编程。发布于 2023-06-25 08:29赞同 2添加评论分享收藏喜欢

8.3. collections — High-performance container datatypes — Python 2.7.18 文档

This document is for an old version of Python that is no longer supported.

You should upgrade and read the

Python 当前稳定版本的文档.

导航

索引

模块 |

下一页 |

上一页 |

Python »

Python 2.7.18 文档 »

Python 标准库 »

8. 数据类型 »

8.3. collections — High-performance container datatypes¶

2.4 新版功能.

Source code: Lib/collections.py and Lib/_abcoll.py

这个模块实现了特定目标的容器，以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。

namedtuple()

创建命名元组子类的工厂函数

2.6 新版功能.

deque

类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)

2.4 新版功能.

Counter

字典的子类，提供了可哈希对象的计数功能

2.7 新版功能.

OrderedDict

字典的子类，保存了他们被添加的顺序

2.7 新版功能.

defaultdict

字典的子类，提供了一个工厂函数，为字典查询提供一个默认值

2.5 新版功能.

In addition to the concrete container classes, the collections module provides

abstract base classes that can be

used to test whether a class provides a particular interface, for example,

whether it is hashable or a mapping.

8.3.1. Counter 对象¶

一个计数器工具提供快速和方便的计数。比如

>>> # Tally occurrences of words in a list

>>> cnt = Counter()

>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:

... cnt[word] += 1

>>> cnt

Counter({'blue': 3, 'red': 2, 'green': 1})

>>> # Find the ten most common words in Hamlet

>>> import re

>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())

>>> Counter(words).most_common(10)

[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),

('you', 554), ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]

class collections.Counter([iterable-or-mapping])¶

A Counter is a dict subclass for counting hashable objects.

It is an unordered collection where elements are stored as dictionary keys

and their counts are stored as dictionary values. Counts are allowed to be

any integer value including zero or negative counts. The Counter

class is similar to bags or multisets in other languages.

元素从一个 iterable 被计数或从其他的 mapping (or counter)初始化：

>>> c = Counter() # a new, empty counter

>>> c = Counter('gallahad') # a new counter from an iterable

>>> c = Counter({'red': 4, 'blue': 2}) # a new counter from a mapping

>>> c = Counter(cats=4, dogs=8) # a new counter from keyword args

Counter对象有一个字典接口，如果引用的键没有任何记录，就返回一个0，而不是弹出一个 KeyError :

>>> c = Counter(['eggs', 'ham'])

>>> c['bacon'] # count of a missing element is zero

设置一个计数为0不会从计数器中移去一个元素。使用 del 来删除它:

>>> c['sausage'] = 0 # counter entry with a zero count

>>> del c['sausage'] # del actually removes the entry

2.7 新版功能.

计数器对象除了字典方法以外，还提供了三个其他的方法：

elements()¶

返回一个迭代器，每个元素重复计数的个数。元素顺序是任意的。如果一个元素的计数小于1， elements() 就会忽略它。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> list(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])¶

Return a list of the n most common elements and their counts from the

most common to the least. If n is omitted or None,

most_common() returns all elements in the counter.

Elements with equal counts are ordered arbitrarily:

>>> Counter('abracadabra').most_common(3)

[('a', 5), ('r', 2), ('b', 2)]

subtract([iterable-or-mapping])¶

从迭代对象或映射对象减去元素。像 dict.update() 但是是减去，而不是替换。输入和输出都可以是0或者负数。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> d = Counter(a=1, b=2, c=3, d=4)

>>> c.subtract(d)

>>> c

Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

通常字典方法都可用于 Counter 对象，除了有两个方法工作方式与字典并不相同。

fromkeys(iterable)¶

这个类方法没有在 Counter 中实现。

update([iterable-or-mapping])¶

从迭代对象计数元素或者从另一个映射对象 (或计数器) 添加。像 dict.update() 但是是加上，而不是替换。另外，迭代对象应该是序列元素，而不是一个 (key, value) 对。

Counter 对象的常用案例

sum(c.values()) # total of all counts

c.clear() # reset all counts

list(c) # list unique elements

set(c) # convert to a set

dict(c) # convert to a regular dictionary

c.items() # convert to a list of (elem, cnt) pairs

Counter(dict(list_of_pairs)) # convert from a list of (elem, cnt) pairs

c.most_common()[:-n-1:-1] # n least common elements

c += Counter() # remove zero and negative counts

提供了几个数学操作，可以结合 Counter 对象，以生产 multisets (计数器中大于0的元素）。加和减，结合计数器，通过加上或者减去元素的相应计数。交集和并集返回相应计数的最小或最大值。每种操作都可以接受带符号的计数，但是输出会忽略掉结果为零或者小于零的计数。

>>> c = Counter(a=3, b=1)

>>> d = Counter(a=1, b=2)

>>> c + d # add two counters together: c[x] + d[x]

Counter({'a': 4, 'b': 3})

>>> c - d # subtract (keeping only positive counts)

Counter({'a': 2})

>>> c & d # intersection: min(c[x], d[x])

Counter({'a': 1, 'b': 1})

>>> c | d # union: max(c[x], d[x])

Counter({'a': 3, 'b': 2})

注解

计数器主要是为了表达运行的正的计数而设计；但是，小心不要预先排除负数或者其他类型。为了帮助这些用例，这一节记录了最小范围和类型限制。

Counter 类是一个字典的子类，不限制键和值。值用于表示计数，但你实际上可以存储任何其他值。

The most_common() method requires only that the values be orderable.

For in-place operations such as c[key] += 1, the value type need only

support addition and subtraction. So fractions, floats, and decimals would

work and negative values are supported. The same is also true for

update() and subtract() which allow negative and zero values

for both inputs and outputs.

Multiset多集合方法只为正值的使用情况设计。输入可以是负数或者0，但只输出计数为正的值。没有类型限制，但值类型需要支持加，减和比较操作。

The elements() method requires integer counts. It ignores zero and

negative counts.

参见

Counter class

adapted for Python 2.5 and an early Bag recipe for Python 2.4.

Bag class 在 Smalltalk。

Wikipedia 链接 Multisets.

C++ multisets 教程和例子。

数学操作和多集合用例，参考 Knuth, Donald. The Art of Computer Programming Volume II, Section 4.6.3, Exercise 19 。

To enumerate all distinct multisets of a given size over a given set of

elements, see itertools.combinations_with_replacement().

map(Counter, combinations_with_replacement(‘ABC’, 2)) –> AA AB AC BB BC CC

8.3.2. deque 对象¶

class collections.deque([iterable[, maxlen]])¶

返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。

Deque队列是由栈或者queue队列生成的（发音是 “deck”，”double-ended queue”的简称）。Deque 支持线程安全，内存高效添加(append)和弹出(pop)，从两端都可以，两个方向的大概开销都是 O(1) 复杂度。

虽然 list 对象也支持类似操作，不过这里优化了定长操作和 pop(0) 和 insert(0, v) 的开销。它们引起 O(n) 内存移动的操作，改变底层数据表达的大小和位置。

2.4 新版功能.

在 2.6 版更改: Added maxlen parameter.

双向队列(deque)对象支持以下方法：

append(x)¶

添加 x 到右端。

appendleft(x)¶

添加 x 到左端。

clear()¶

移除所有元素，使其长度为0.

count(x)¶

计算 deque 中元素等于 x 的个数。

2.7 新版功能.

extend(iterable)¶

扩展deque的右侧，通过添加iterable参数中的元素。

extendleft(iterable)¶

扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。

pop()¶

移去并且返回一个元素，deque 最右侧的那一个。如果没有元素的话，就引发一个 IndexError。

popleft()¶

移去并且返回一个元素，deque 最左侧的那一个。如果没有元素的话，就引发 IndexError。

remove(value)¶

移除找到的第一个 value。如果没有的话就引发 ValueError。

2.5 新版功能.

reverse()¶

将deque逆序排列。返回 None 。

2.7 新版功能.

rotate(n=1)¶

向右循环移动 n 步。如果 n 是负数，就向左循环。

如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ，向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

maxlen¶

Deque的最大尺寸，如果没有限定的话就是 None 。

2.7 新版功能.

除了以上，deque还支持迭代，清洗，len(d), reversed(d), copy.copy(d), copy.deepcopy(d), 成员测试 in 操作符，和下标引用 d[-1] 。索引存取在两端的复杂度是 O(1)，在中间的复杂度比 O(n) 略低。要快速存取，使用list来替代。

示例:

>>> from collections import deque

>>> d = deque('ghi') # make a new deque with three items

>>> for elem in d: # iterate over the deque's elements

... print elem.upper()

>>> d.append('j') # add a new entry to the right side

>>> d.appendleft('f') # add a new entry to the left side

>>> d # show the representation of the deque

deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop() # return and remove the rightmost item

'j'

>>> d.popleft() # return and remove the leftmost item

'f'

>>> list(d) # list the contents of the deque

['g', 'h', 'i']

>>> d[0] # peek at leftmost item

'g'

>>> d[-1] # peek at rightmost item

'i'

>>> list(reversed(d)) # list the contents of a deque in reverse

['i', 'h', 'g']

>>> 'h' in d # search the deque

True

>>> d.extend('jkl') # add multiple elements at once

>>> d

deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> d.rotate(1) # right rotation

>>> d

deque(['l', 'g', 'h', 'i', 'j', 'k'])

>>> d.rotate(-1) # left rotation

>>> d

deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d)) # make a new deque in reverse order

deque(['l', 'k', 'j', 'i', 'h', 'g'])

>>> d.clear() # empty the deque

>>> d.pop() # cannot pop from an empty deque

Traceback (most recent call last):

File "", line 1, in -toplevel-

d.pop()

IndexError: pop from an empty deque

>>> d.extendleft('abc') # extendleft() reverses the input order

>>> d

deque(['c', 'b', 'a'])

8.3.2.1. deque 用法¶

这一节展示了deque的多种用法。

限长deque提供了类似Unix tail 过滤功能

def tail(filename, n=10):

'Return the last n lines of a file'

return deque(open(filename), n)

另一个用法是维护一个近期添加元素的序列，通过从右边添加和从左边弹出

def moving_average(iterable, n=3):

# moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0

# http://en.wikipedia.org/wiki/Moving_average

it = iter(iterable)

d = deque(itertools.islice(it, n-1))

d.appendleft(0)

s = sum(d)

for elem in it:

s += elem - d.popleft()

d.append(elem)

yield s / float(n)

The rotate() method provides a way to implement deque slicing and

deletion. For example, a pure Python implementation of del d[n] relies on

the rotate() method to position elements to be popped:

def delete_nth(d, n):

d.rotate(-n)

d.popleft()

d.rotate(n)

To implement deque slicing, use a similar approach applying

rotate() to bring a target element to the left side of the deque. Remove

old entries with popleft(), add new entries with extend(), and then

reverse the rotation.

With minor variations on that approach, it is easy to implement Forth style

stack manipulations such as dup, drop, swap, over, pick,

rot, and roll.

8.3.3. defaultdict 对象¶

class collections.defaultdict([default_factory[, ...]])¶

返回一个新的类似字典的对象。 defaultdict 是内置 dict 类的子类。它重载了一个方法并添加了一个可写的实例变量。其余的功能与 dict 类相同，此处不再重复说明。

第一个参数 default_factory 提供了一个初始值。它默认为 None 。所有的其他参数都等同与 dict 构建器中的参数对待，包括关键词参数。

2.5 新版功能.

defaultdict 对象除了支持 dict 的操作，还支持下面的方法作为扩展:

__missing__(key)¶

如果 default_factory 属性为 None，则调用本方法会抛出 KeyError 异常，附带参数 key。

如果 default_factory 不为 None ，它就会会被调用，不带参数，为 key 提供一个默认值，这个值和 key 作为一个对被插入到字典中，并返回。

如果调用 default_factory 时抛出了异常，这个异常会原封不动地向外层传递。

在无法找到所需键值时，本方法会被 dict 中的 __getitem__() 方法调用。无论本方法返回了值还是抛出了异常，都会被 __getitem__() 传递。

注意 __missing__() 不会被 __getitem__() 以外的其他方法调用。意思就是 get() 会向正常的dict那样返回 None ，而不是使用 default_factory 。

defaultdict 支持以下实例变量:

default_factory¶

这个属性被 __missing__() 方法使用；它从构建器的第一个参数初始化，如果提供了的话，否则就是 None 。

8.3.3.1. defaultdict 例子¶

Using list as the default_factory, it is easy to group a

sequence of key-value pairs into a dictionary of lists:

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

>>> d = defaultdict(list)

>>> for k, v in s:

... d[k].append(v)

...

>>> d.items()

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

When each key is encountered for the first time, it is not already in the

mapping; so an entry is automatically created using the default_factory

function which returns an empty list. The list.append()

operation then attaches the value to the new list. When keys are encountered

again, the look-up proceeds normally (returning the list for that key) and the

list.append() operation adds another value to the list. This technique is

simpler and faster than an equivalent technique using dict.setdefault():

>>> d = {}

>>> for k, v in s:

... d.setdefault(k, []).append(v)

...

>>> d.items()

[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

Setting the default_factory to int makes the

defaultdict useful for counting (like a bag or multiset in other

languages):

>>> s = 'mississippi'

>>> d = defaultdict(int)

>>> for k in s:

... d[k] += 1

...

>>> d.items()

[('i', 4), ('p', 2), ('s', 4), ('m', 1)]

When a letter is first encountered, it is missing from the mapping, so the

default_factory function calls int() to supply a default count of

zero. The increment operation then builds up the count for each letter.

The function int() which always returns zero is just a special case of

constant functions. A faster and more flexible way to create constant functions

is to use itertools.repeat() which can supply any constant value (not just

zero):

>>> def constant_factory(value):

... return itertools.repeat(value).next

>>> d = defaultdict(constant_factory(''))

>>> d.update(name='John', action='ran')

>>> '%(name)s %(action)s to %(object)s' % d

'John ran to '

Setting the default_factory to set makes the

defaultdict useful for building a dictionary of sets:

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]

>>> d = defaultdict(set)

>>> for k, v in s:

... d[k].add(v)

...

>>> d.items()

[('blue', set([2, 4])), ('red', set([1, 3]))]

8.3.4. namedtuple() 命名元组的工厂函数¶

命名元组赋予每个位置一个含义，提供可读性和自文档性。它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。

collections.namedtuple(typename, field_names[, verbose=False][, rename=False])¶

返回一个新的元组子类，名为 typename 。这个新的子类用于创建类元组的对象，可以通过域名来获取属性值，同样也可以通过索引和迭代获取值。子类实例同样有文档字符串（类名和域名）另外一个有用的 __repr__() 方法，以 name=value 格式列明了元组内容。

field_names 是一个像 [‘x’, ‘y’] 一样的字符串序列。另外 field_names 可以是一个纯字符串，用空白或逗号分隔开元素名，比如 'x y' 或者 'x, y' 。

Any valid Python identifier may be used for a fieldname except for names

starting with an underscore. Valid identifiers consist of letters, digits,

and underscores but do not start with a digit or underscore and cannot be

a keyword such as class, for, return, global, pass, print,

or raise.

如果 rename 为真，无效域名会自动转换成位置名。比如 ['abc', 'def', 'ghi', 'abc'] 转换成 ['abc', '_1', 'ghi', '_3'] ，消除关键词 def 和重复域名 abc 。

If verbose is true, the class definition is printed just before being built.

命名元组实例没有字典，所以它们要更轻量，并且占用更小内存。

2.6 新版功能.

在 2.7 版更改: added support for rename.

示例:

>>> Point = namedtuple('Point', ['x', 'y'], verbose=True)

class Point(tuple):

'Point(x, y)'

__slots__ = ()

_fields = ('x', 'y')

def __new__(_cls, x, y):

'Create new instance of Point(x, y)'

return _tuple.__new__(_cls, (x, y))

@classmethod

def _make(cls, iterable, new=tuple.__new__, len=len):

'Make a new Point object from a sequence or iterable'

result = new(cls, iterable)

if len(result) != 2:

raise TypeError('Expected 2 arguments, got %d' % len(result))

return result

def __repr__(self):

'Return a nicely formatted representation string'

return 'Point(x=%r, y=%r)' % self

def _asdict(self):

'Return a new OrderedDict which maps field names to their values'

return OrderedDict(zip(self._fields, self))

def _replace(_self, **kwds):

'Return a new Point object replacing specified fields with new values'

result = _self._make(map(kwds.pop, ('x', 'y'), _self))

if kwds:

raise ValueError('Got unexpected field names: %r' % kwds.keys())

return result

def __getnewargs__(self):

'Return self as a plain tuple. Used by copy and pickle.'

return tuple(self)

__dict__ = _property(_asdict)

def __getstate__(self):

'Exclude the OrderedDict from pickling'

pass

x = _property(_itemgetter(0), doc='Alias for field number 0')

y = _property(_itemgetter(1), doc='Alias for field number 1')

>>> p = Point(11, y=22) # instantiate with positional or keyword arguments

>>> p[0] + p[1] # indexable like the plain tuple (11, 22)

>>> x, y = p # unpack like a regular tuple

>>> x, y

(11, 22)

>>> p.x + p.y # fields also accessible by name

>>> p # readable __repr__ with a name=value style

Point(x=11, y=22)

命名元组尤其有用于赋值 csv sqlite3 模块返回的元组

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv

for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):

print emp.name, emp.title

import sqlite3

conn = sqlite3.connect('/companydata')

cursor = conn.cursor()

cursor.execute('SELECT name, age, title, department, paygrade FROM employees')

for emp in map(EmployeeRecord._make, cursor.fetchall()):

print emp.name, emp.title

In addition to the methods inherited from tuples, named tuples support

three additional methods and one attribute. To prevent conflicts with

field names, the method and attribute names start with an underscore.

classmethod somenamedtuple._make(iterable)¶

类方法从存在的序列或迭代实例创建一个新实例。

>>> t = [11, 22]

>>> Point._make(t)

Point(x=11, y=22)

somenamedtuple._asdict()¶

Return a new OrderedDict which maps field names to their corresponding

values:

>>> p = Point(x=11, y=22)

>>> p._asdict()

OrderedDict([('x', 11), ('y', 22)])

在 2.7 版更改: 返回一个 OrderedDict 而不是 dict 。

somenamedtuple._replace(**kwargs)¶

返回一个新的命名元组实例，并将指定域替换为新的值

>>> p = Point(x=11, y=22)

>>> p._replace(x=33)

Point(x=33, y=22)

>>> for partnum, record in inventory.items():

... inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())

somenamedtuple._fields¶

字符串元组列出了域名。用于提醒和从现有元组创建一个新的命名元组类型。

>>> p._fields # view the field names

('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')

>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)

>>> Pixel(11, 22, 128, 255, 0)

Pixel(x=11, y=22, red=128, green=255, blue=0)

要获取这个名字域的值，使用 getattr() 函数 :

>>> getattr(p, 'x')

To convert a dictionary to a named tuple, use the double-star-operator

(as described in 解包参数列表):

>>> d = {'x': 11, 'y': 22}

>>> Point(**d)

Point(x=11, y=22)

因为一个命名元组是一个正常的Python类，它可以很容易的通过子类更改功能。这里是如何添加一个计算域和定宽输出打印格式:

>>> class Point(namedtuple('Point', 'x y')):

... __slots__ = ()

... @property

... def hypot(self):

... return (self.x ** 2 + self.y ** 2) ** 0.5

... def __str__(self):

... return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)

...

>>> for p in Point(3, 4), Point(14, 5/7.):

... print p

Point: x= 3.000 y= 4.000 hypot= 5.000

Point: x=14.000 y= 0.714 hypot=14.018

上面的子类设置 __slots__ 为一个空元组。通过阻止创建实例字典保持了较低的内存开销。

Subclassing is not useful for adding new, stored fields. Instead, simply

create a new named tuple type from the _fields attribute:

>>> Point3D = namedtuple('Point3D', Point._fields + ('z',))

Default values can be implemented by using _replace() to

customize a prototype instance:

>>> Account = namedtuple('Account', 'owner balance transaction_count')

>>> default_account = Account('', 0.0, 0)

>>> johns_account = default_account._replace(owner='John')

Enumerated constants can be implemented with named tuples, but it is simpler

and more efficient to use a simple class declaration:

>>> Status = namedtuple('Status', 'open pending closed')._make(range(3))

>>> Status.open, Status.pending, Status.closed

(0, 1, 2)

>>> class Status:

... open, pending, closed = range(3)

参见

Named tuple recipe

adapted for Python 2.4.

8.3.5. OrderedDict 对象¶

Ordered dictionaries are just like regular dictionaries but they remember the

order that items were inserted. When iterating over an ordered dictionary,

the items are returned in the order their keys were first added.

class collections.OrderedDict([items])¶

Return an instance of a dict subclass, supporting the usual dict

methods. An OrderedDict is a dict that remembers the order that keys

were first inserted. If a new entry overwrites an existing entry, the

original insertion position is left unchanged. Deleting an entry and

reinserting it will move it to the end.

2.7 新版功能.

OrderedDict.popitem(last=True)¶

The popitem() method for ordered dictionaries returns and removes

a (key, value) pair. The pairs are returned in LIFO order if last is

true or FIFO order if false.

相对于通常的映射方法，有序字典还另外提供了逆序迭代的支持，通过 reversed() 。

Equality tests between OrderedDict objects are order-sensitive

and are implemented as list(od1.items())==list(od2.items()).

Equality tests between OrderedDict objects and other

Mapping objects are order-insensitive like regular

dictionaries. This allows OrderedDict objects to be substituted

anywhere a regular dictionary is used.

The OrderedDict constructor and update() method both accept

keyword arguments, but their order is lost because Python’s function call

semantics pass-in keyword arguments using a regular unordered dictionary.

参见

Equivalent OrderedDict recipe

that runs on Python 2.4 or later.

8.3.5.1. OrderedDict 例子和用法¶

Since an ordered dictionary remembers its insertion order, it can be used

in conjunction with sorting to make a sorted dictionary:

>>> # regular unsorted dictionary

>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key

>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))

OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value

>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))

OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string

>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))

OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

The new sorted dictionaries maintain their sort order when entries

are deleted. But when new keys are added, the keys are appended

to the end and the sort is not maintained.

It is also straight-forward to create an ordered dictionary variant

that remembers the order the keys were last inserted.

If a new entry overwrites an existing entry, the

original insertion position is changed and moved to the end:

class LastUpdatedOrderedDict(OrderedDict):

'Store items in the order the keys were last added'

def __setitem__(self, key, value):

if key in self:

del self[key]

OrderedDict.__setitem__(self, key, value)

An ordered dictionary can be combined with the Counter class

so that the counter remembers the order elements are first encountered:

class OrderedCounter(Counter, OrderedDict):

'Counter that remembers the order elements are first encountered'

def __repr__(self):

return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

def __reduce__(self):

return self.__class__, (OrderedDict(self),)

8.3.6. Collections Abstract Base Classes¶

The collections module offers the following ABCs:

ABC

Inherits from

Abstract Methods

Mixin Methods

Container

__contains__

Hashable

__hash__

Iterable

__iter__

Iterator

Iterable

__iter__

Sized

__len__

Callable

__call__

Sequence

Sized,

Iterable,

Container

__getitem__,

__len__

__contains__, __iter__, __reversed__,

index, and count

MutableSequence

Sequence

__getitem__,

__setitem__,

__delitem__,

__len__,

insert

Inherited Sequence methods and

append, reverse, extend, pop,

remove, and __iadd__

Set

Sized,

Iterable,

Container

__contains__,

__iter__,

__len__

__le__, __lt__, __eq__, __ne__,

__gt__, __ge__, __and__, __or__,

__sub__, __xor__, and isdisjoint

MutableSet

Set

__contains__,

__iter__,

__len__,

add,

discard

Inherited Set methods and

clear, pop, remove, __ior__,

__iand__, __ixor__, and __isub__

Mapping

Sized,

Iterable,

Container

__getitem__,

__iter__,

__len__

__contains__, keys, items, values,

get, __eq__, and __ne__

MutableMapping

Mapping

__getitem__,

__setitem__,

__delitem__,

__iter__,

__len__

Inherited Mapping methods and

pop, popitem, clear, update,

and setdefault

MappingView

Sized

__len__

ItemsView

MappingView,

Set

__contains__,

__iter__

KeysView

MappingView,

Set

__contains__,

__iter__

ValuesView

MappingView

__contains__, __iter__

class collections.Container¶

class collections.Hashable¶

class collections.Sized¶

class collections.Callable¶

ABCs for classes that provide respectively the methods __contains__(),

__hash__(), __len__(), and __call__().

class collections.Iterable¶

ABC for classes that provide the __iter__() method.

Python Collections库的高级功能详解-CSDN博客

Python Collections库的高级功能详解

最新推荐文章于 2024-03-07 16:27:48 发布

Sitin涛哥

最新推荐文章于 2024-03-07 16:27:48 发布

阅读量767

点赞数

分类专栏：

Python

文章标签：

python

数据库

开发语言

本文链接：https://blog.csdn.net/wuShiJingZuo/article/details/134805129

版权

Python

专栏收录该内容

970 篇文章

14 订阅

订阅专栏

更多资料获取

个人网站：ipengtao.com

Python的collections库提供了一系列有用的数据类型，扩展了内建的数据类型，为开发者提供了更多高级功能。本文将深入探讨collections库的一些高级功能，通过详细的示例代码演示，帮助大家更好地理解和应用这些功能。

Counter：计数器

Counter是collections库中强大的计数器工具，用于统计可迭代对象中元素的出现次数。

通过一个实例来了解其用法：

from collections import Counter

# 示例数据

data = [1, 2, 3, 1, 2, 3, 4, 5, 1, 2, 3, 1, 2]

# 创建计数器

counter = Counter(data)

# 输出计数结果

print(counter)

这将输出：Counter({1: 4, 2: 4, 3: 3, 4: 1, 5: 1})，表示元素1出现了4次，元素2出现了4次，以此类推。

defaultdict：默认字典

defaultdict是一种字典的子类，它允许指定默认值，并在访问不存在的键时返回该默认值。

以下是一个使用示例：

from collections import defaultdict

# 创建默认字典，指定默认值为0

counter = defaultdict(int)

# 示例数据

data = [1, 2, 3, 1, 2, 3, 4, 5, 1, 2, 3, 1, 2]

# 计数

for num in data:

counter[num] += 1

# 输出计数结果

print(dict(counter))

这将输出：{1: 4, 2: 4, 3: 3, 4: 1, 5: 1}，与Counter的结果相同。

namedtuple：命名元组

namedtuple创建了带有字段名的元组，使得元组更具可读性和自描述性。

下面是一个简单的使用示例：

from collections import namedtuple

# 定义命名元组结构

Person = namedtuple('Person', ['name', 'age', 'gender'])

# 创建命名元组实例

person = Person(name='Alice', age=25, gender='Female')

# 访问字段

print(person.name, person.age, person.gender)

这将输出：Alice 25 Female，使得元组的字段更容易理解和使用。

ChainMap：链式映射

ChainMap是一种合并多个字典或映射的方法，使得它们可以在逻辑上形成一个链。可以在一个操作中访问多个映射，而无需手动合并它们。

以下是一个示例：

from collections import ChainMap

# 创建两个字典

dict1 = {'a': 1, 'b': 2}

dict2 = {'b': 3, 'c': 4}

# 创建ChainMap

chain_map = ChainMap(dict1, dict2)

# 访问元素

print(chain_map['a']) # 输出: 1

print(chain_map['b']) # 输出: 2 （来自dict1）

print(chain_map['c']) # 输出: 4 （来自dict2）

Counter的高级用法

Counter不仅可以用于简单的计数，还支持一些高级的操作，如计算两个计数器的交集、并集等。

以下是一个例子：

from collections import Counter

# 创建两个计数器

counter1 = Counter(a=3, b=1, c=4)

counter2 = Counter(a=1, b=2, c=5)

# 计算交集

intersection = counter1 & counter2

print(intersection) # 输出: Counter({'a': 1, 'b': 1, 'c': 4})

UserDict：自定义字典的基类

UserDict是一个用于创建字典的基类，可以方便地定义自己的字典类，而不必从头开始实现所有字典的特性。

以下是一个简单的示例：

from collections import UserDict

class MyDict(UserDict):

def __setitem__(self, key, value):

# 自定义设置项的操作

print(f"Setting key: {key}, value: {value}")

super().__setitem__(key, value)

# 使用自定义字典

my_dict = MyDict()

my_dict['a'] = 1 # 输出: Setting key: a, value: 1

性能考虑

在使用collections库的高级功能时，性能是一个重要的考虑因素。不同功能的性能特性可能在不同场景下表现出差异，因此在实际应用中，建议进行详细的性能测试以选择最适合特定需求的数据结构和算法。

例如，在处理大规模数据时，使用Counter进行计数可能会相对较快，但在其他情况下，可能需要权衡使用不同的功能。了解每个功能的底层实现原理和适用场景，可以帮助开发者在性能和功能之间做出明智的选择。

在性能关键的应用中，还可以考虑使用专门针对特定场景优化的第三方库，以获得更高效的处理能力。总体而言，在编写代码时要根据实际需求和场景选择合适的collections库的高级功能，并通过性能测试来确保其在特定条件下的高效运行。

总结

Python的collections库提供了丰富而强大的数据结构和工具，能够满足各种编程需求。在本文中，分享了库中一些高级功能，如ChainMap、Counter的高级用法以及UserDict的自定义字典类。通过理解和灵活运用这些功能，开发者能够更高效地处理数据和优化代码。

在使用这些高级功能时，强调了性能的重要性。不同功能在不同场景下的性能表现可能存在差异，因此建议在性能关键的应用中进行详细的测试和评估，以确保选择最适合具体需求的数据结构和算法。此外，还有在实际应用中权衡不同功能的取舍，以及在一些特定场景下考虑使用专门优化的第三方库。

总体而言，collections库为Python开发者提供了强大的工具，通过深入学习和实践，开发者能够编写出更为高效、清晰的代码。

Python学习路线

更多资料获取

个人网站：ipengtao.com

如果还想要领取更多更丰富的资料，可以点击文章下方名片，回复【优质资料】，即可获取全方位学习资料包。

点击文章下方链接卡片，回复【优质资料】，可直接领取资料大礼包。

优惠劵

Sitin涛哥

关注

踩

觉得还不错?

一键收藏

知道了

Python Collections库的高级功能详解

UserDict是一个用于创建字典的基类，可以方便地定义自己的字典类，而不必从头开始实现所有字典的特性。# 自定义设置项的操作from collections import UserDict class MyDict(UserDict) : def __setitem__(self , key , value) : # 自定义设置项的操作 print(f"Setting key: {

复制链接

扫一扫

专栏目录

详细分析Python collections工具库

09-16

主要介绍了详解Python collections工具库的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下

Python collections.defaultdict模块用法详解

09-16

参与评论

您还未登录，请先

后发表或查看评论

Python collections模块使用方法详解

09-18

主要介绍了Python collections模块使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

详解Python 中的容器 collections

09-16

主要介绍了Python 中的容器 collections的相关资料，帮助大家更好的理解和学习python，感兴趣的朋友可以了解下

Python 语法高亮显示和格式化库之pygments使用详解

Rocky006的博客

03-07

696

在软件开发和编程领域，代码是我们的主要表达方式。因此，对于代码的可读性和可理解性至关重要。为了提高代码的可读性，代码语法高亮和格式化工具变得至关重要。在Python世界中，Pygments是一个强大的工具，它可以帮助开发人员高亮显示和格式化他们的代码。本文将深入探讨Pygments的功能、用法和示例代码，以及如何将其集成到你的项目中。

Java的 Map以及实现一个简单的红黑树

好看的皮囊千篇一律，有趣的灵魂万里挑一。

03-07

622

Map是将键映射到值的对象。map**不能包含重复的键**; 每个键最多只能映射到一个值。这个接口取代了Dictionary类，Dictionary类是一个完全抽象的类，而不是接口。

Map接口提供了三个集合视图，它们允许将映射的内容视为一组键、一组值或一组键-值映射。映射的顺序定义为映射集合视图上的迭代器返回其元素的顺序。一些类似实现，比如TreeMap类，对它们的顺序做出了特定的保证;其他类，如HashMap类，则不需要。

注意:如果使用可变对象作为映射键，必须非常小心。如果对象的值以影响相等比较的

MAE实战：使用MAE提高主干网络的精度(二)

AI浩

03-04

976

看完第一篇，大家应该对MAE的训练流程有所了解了。链接：https://blog.csdn.net/hhhhhhhhhhwwwwwwwwww/article/details/136022910?这篇再讲述一篇案例，我们一起实现吧！

mac笔记本检查是否安装成功pandas

技术刚刚好

03-04

278

是否成功安装，你可以打开 Python 解释器并尝试导入。是否已经成功安装并且可以在 Python 中正常使用。以下是在 Python 中检查。的版本信息，你可以确认。

【python课程作业】python学生成绩管理系统

疯狂屌丝程序员

03-05

753

平台采用B/S结构，后端采用主流的Python语言进行开发，前端采用主流的Vue.js进行开发。给舍友做的课程作业。功能包括：成绩管理、学生管理、课程管理、班级管理、用户管理、日志管理、系统信息模块。

每天一个数据分析题（一百八十五）

shiguangre的博客

03-04

293

给定下述Python代码段，试问哪个选项正确描述了该代码段的功能？

python: 创建目录，类似 ‘mkdir -p‘

qq_40256654的博客

03-05

466

os.makedirs 是 Python 的一个函数，属于 os 模块，用于递归创建目录。如果创建的目录的父目录不存在，os.makedirs 会自动创建这些父目录，类似于 Unix 和 Linux 命令行中的 mkdir -p 命令。这个函数对于需要创建多层嵌套的目录结构时特别有用。函数语法pythonCopy codename: 要创建的目录的路径。

折线图温度变化曲线图

weixin_63131036的博客

03-05

153

【代码】折线图温度变化曲线图。

PAT知识点——python一行输入多个整数，并以空格间隔

Bingyeshinvwang的博客

03-04

333

用户输入两个整数，并用空格分隔。python实现

python的数据容器--list列表

Python中的collections库_micropython ucollections库介绍-CSDN博客

Python中的collections库

最新推荐文章于 2024-03-07 11:12:40 发布

坚果儿儿

最新推荐文章于 2024-03-07 11:12:40 发布

阅读量1.4k

点赞数

分类专栏：

笔记

文章标签：

python

原文链接：https://mp.weixin.qq.com/s/ymLPuQxEN_FUHYmWaGOU1g

版权

笔记

专栏收录该内容

11 篇文章

1 订阅

订阅专栏

Python中的collections库

介绍Python当中一个很好用也是很基础的工具库，叫做collections

collection在英文当中有容器的意思，所以顾名思义，这是一个容器的集合。这个库当中的容器很多，有一些不是很常用，本篇文章选择了其中最常用的几个介绍。

defaultdict

defaultdict可以说是这个库当中使用最简单的一个，并且它的定义也很简单，我们从名称基本上就能看得出来。它解决的是我们使用dict当中最常见的问题，就是key为空的情况。

在正常情况下，我们在dict中获取元素的时候，都需要考虑key为空的情况。如果不考虑这点，那么当我们获取了一个不存在的key，会导致系统抛出异常。我们当然可以在每次get之前写一个if判断，但是这很麻烦，比如：

if key in dict:

return dict[key]

else:

return None

当然，这是最笨的方法，dict当中为我们提供了带默认值的get方法。比如，我们可以写成：

return dict.get(key, None)

这样，当key不在dict当中存在的时候，会自动返回我们设置的默认值。这个省去了很多麻烦的判断，但是在一些特殊情况下仍然存在一点问题。举个例子，比如当key存在重复，我们希望将key相同的value存进一个list当中，而不是只保留一个。这种情况下写成代码就会比较复杂：

data = [(1, 3), (2, 1), (1, 4), (2, 5), (3, 7)]

d = {}

for k, v in data:

if k in d:

d[k].append(v)

else:

d[k] = [v]

print(d,type(d))

>>>{1: [3, 4], 2: [1, 5], 3: [7]}

由于dict的value是一个list，所以我们还是需要判断是否为空，不能直接使用默认值，间接操作当然可以，但是还是不够简单：

for k, v in data:

cur = d.get(k, [])

cur.append(v)

d[k] = v

这和使用if区别并不大，为了完美解决这个问题，我们可以使用collections当中的defaultdict：

from collections import defaultdict

d = defaultdict(list)

for k, v in data:

d[k].append(v)

使用defaultdict之后，如果key不存在，容器会自动返回我们预先设置的默认值。需要注意的是defaultdict传入的默认值可以是一个类型也可以是一个方法。如果我们传入int，那么默认值会被设置成int()的结果，也就是0，如果我们想要自定义或者修改，我们可以传入一个方法，比如：

d = defaultdict(lambda: 3)

for k, v in data:

d[k] += v

[defaultdict用法详解] https://www.cnblogs.com/jidongdeatao/p/6930325.html)

Counter

这是一个非常常用和非常强大的工具，我们经常用到。

在我们实际的编程当中，我们经常遇到一个问题，就是数数和排序。比如说我们在分析文本的时候，会得到一堆单词。其中可能有大量的长尾词，在整个文本当中可能只出现过寥寥几次。于是我们希望计算一下这些单词出现过的数量，只保留出现次数最高的若干个。

这个需求让我们自己实现当然也不困难，我们完全可以创建一个dict，然后对这些单词一个一个遍历。原本我们还需要考虑单词之前没有出现过的情况，如果我们上面说的defaultdict，又要简单许多。但是我们还是少不了计数然后排序的步骤，如果使用Counter这个步骤会缩减成一行代码。

举个例子：

words = ['apple', 'apple', 'pear', 'watermelon', 'pear', 'peach']

from collections import Counter

counter = Counter(words)

>>> print(counter)

Counter({'apple': 2, 'pear': 2, 'watermelon': 1, 'peach': 1})

我们直接将一个list传入Counter中作为参数，它会自动为我们当中的每个元素计数。

如果我们要筛选topK，也非常简单，它为我们提供了most_common方法，我们只需要传入需要求的K即可：

counter.most_common(1)

[('apple', 2)]

除此之外，它的构造函数还接收dict类型。我们可以直接通过一个value是int类型的dict来初始化一个Counter，比如：

c = Counter({'apple': 5, 'pear': 4})

c = Counter(apple=4, pear=3)

并且，它还支持加减法的操作，比如我们可以将两个Counter相加，它会自动将两个Counter合并，相同的key对应的value累加。相减也是同理，会将能对应的value做减法，被减的key对应不上的会保留，而减数中对应不上的key则会被丢弃。并且需要注意，Counter支持value为负数。

deque

我们都知道queue是队列，deque也是队列，不过稍稍特殊一些，是双端队列。对于queue来说，只允许在队尾插入元素，在队首弹出元素。而deque既然称为双端队列，那么说明它的队首和队尾都支持元素的插入和弹出。相比于普通的队列，要更加灵活一些。

除了常用的clear、copy、count、extend等api之外，deque当中最常用也是最核心的api还有append、pop、appendleft和popleft。从名字上我们就看得出来，append和pop和list的append和pop一样，而appendleft和popleft则是在队列左侧，也就是头部进行pop和append的操作。非常容易理解。

在日常的使用当中，真正用到双端队列的算法其实不太多。大多数情况下我们使用deque主要有两个原因，第一个原因是deque收到全局锁GIL(Global Interpreter Lock)的管理，它是线程安全的。而list则没有GIL锁，因此不是线程安全的。也就是说在并发场景下，list可能会导致一致性问题，而deque不会。另一个原因是deque支持固定长度，当长度满了之后，当我们继续append时，它会自动弹出最早插入的数据。全局锁GIL 关于分布式系统中一致性问题数据一致性如何解决一致性问题比如说当我们拥有海量的数据，我们不知道它的数量，但是想要保留最后出现的指定数量的数据的时候，就可以使用deque。

from collections import deque

dque = deque(maxlen=10)

假设我们想要从文件当中获取最后10条数据

for i in f.read():

dque.append(i)

namedtuple

namedtuple很特殊，它涉及到元编程的概念。简单介绍一下元编程的概念，我们不做过多的深入。简而言之，就是在常见的面向对象当中。我们都是定义类，然后通过类的构造函数来创建实例。而元编程指的是我们定义元类，根据元类创建出来的并不是一个实例，而是一个类。如果用模具和成品来分别比喻类和实例的话，元类相当于是模具的模具。

namedtuple是一个非常简单的元类，通过它我们可以非常方便地定义我们想要的类。

它的用法很简单，我们直接来看例子。比如如果我们想要定义一个学生类，这个类当中有name、score、age这三个字段，那么这个类会写成：

class Student:

def __init__(self, name=None, score=None, age=None):

self.name = name

self.score = score

self.age = age

这还只是粗略的写法，如果考虑规范，还需要定义property等注解，又需要很多代码。如果我们使用namedtuple可以简化这个工作，我们来看代码：

from collections import namedtuple

# 这个是类，columns也可以写成'name score age'，即用空格分开

Student = namedtuple('Student', ['name', 'score', 'age'])

#这个是实例

student = Student(name='xiaoming', score=99, age=10)

print(student.name)

通过使用namedtuple，我们只需要一行就定义了一个类，但是这样定义的类是没有缺失值的，但是namedtuple很强大，我们可以通过传入defaults参数来定义缺失值。

Student = namedtuple('Student', ['name', 'score', 'age'], defaults=(0, 0))

可以注意到，虽然我们定义了三个字段，但是我们只设置了两个缺失值。在这种情况下，namedtuple会自动将缺失值匹配上score和age两个字段。因为在Python的规范当中，必选参数一定在可选参数前面。所以nuamdtuple会自动右对齐。

细数一下，我们今天的文章当中介绍了defaultdict、Counter、deque和namedtuple这四种数据结构的用法。除了这四个之外，collections库当中还有一些其他的工具类，只是我们用的频率稍稍低一些，加上由于篇幅的原因，这里就不多做赘述了。感兴趣的同学可以自行查看相关的api和文档。

优惠劵

坚果儿儿

关注

踩

觉得还不错?

一键收藏

知道了

Python中的collections库

介绍Python当中一个很好用也是很基础的工具库，叫做collectionscollection在英文当中有容器的意思，所以顾名思义，这是一个容器的集合。这个库当中的容器很多，有一些不是很常用，本篇文章选择了其中最常用的几个介绍。defaultdictdefaultdict可以说是这个库当中使用最简单的一个，并且它的定义也很简单，我们从名称基本上就能看得出来。它解决的是我们使用dict当中最常见的问题，就是key为空的情况。在正常情况下，我们在dict中获取元素的时候，都需要考虑key为空的情况。如

复制链接

扫一扫

专栏目录

collection-json.python:处理 Collection+JSON 文档的简单 python 库

06-21

集合-json

collection-json 是一个用 Python 编写的小型库，用于处理 Collection+JSON 文档。

安装

安装 collection-json 最简单的方法是运行

$ pip install collection-json

其他安装方式请参考。

例子

解析一个 Collection+JSON 文档真的很简单

>>> import requests

>>> from collection_json import Collection

>>> data = requests.get('http://www.youtypeitwepostit.com/api/').text

>>> collection = Collection.from_json(data)

>>> collection

'UserString', '_Link', '_OrderedDictItemsView', '_OrderedDictKeysView',

'_OrderedDictValuesView', '__all__', '__builtins__', '__.

python的collection_python--模块之collection

weixin_42363600的博客

12-24

6929

collection模块:在内置数据类型(dict、list、set、tuple)的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。1:namedtuple生成可以使用名字来访问元素内容的元组(tuple)例如：表示一个坐标from collections import namedtu...

详细分析Python collections工具库

12-17

今天为大家介绍Python当中一个很好用也是很基础的工具库，叫做collections。

collection在英文当中有容器的意思，所以顾名思义，这是一个容器的集合。这个库当中的容器很多，有一些不是很常用，本篇文章选择了其中最常用的几个，一起介绍给大家。

defaultdict

在正常情况下，我们在dict中获取元素的时候，都需要考虑key为空的情况。如果不考虑这点，那么当我们获取了一个不存在的key，会导致系统抛出

Python中collections模块介绍

12-22

当我们退出python解释器后重新进入，之前定义的函数或者变量都将丢失，所以通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。随着程序的发展，功能...

Python中Collections模块的Counter容器类使用教程

09-21

Counter是Python标准库提供的一个非常有用的容器,可以用来对序列中出现的各个元素进行计数,下面就来一起看一下Python中Collections模块的Counter容器类使用教程

Python标准库之collections包的使用教程

09-21

主要给大家介绍了Python标准库之collections包的使用教程，详细介绍了collections中多个集合类的使用方法，相信对大家具有一定的参考价值，需要的朋友们下面随小编一起来学习学习吧。

Python 语法高亮显示和格式化库之pygments使用详解

Rocky006的博客

03-07

696

Java的 Map以及实现一个简单的红黑树

im钱包App官网最新版下载 数字资产服务平台

imtoken最新苹果安卓版|collections库

【万字长文详解】Python库collections，让你击败99%的Pythoner - 知乎

Python——详解collections工具库 - 知乎

Python中 collections模块的详细用法介绍_python collections-CSDN博客

collections --- 容器数据类型 — Python 3.12.2 文档

python标准库: collections介绍 - 知乎

collections - 廖雪峰的官方网站

如何在 Python 中使用 collections 模块？ - 知乎

8.3. collections — High-performance container datatypes — Python 2.7.18 文档

Python Collections库的高级功能详解-CSDN博客

Python中的collections库_micropython ucollections库介绍-CSDN博客

im钱包App官网最新版下载
数字资产服务平台