Collections模块
1. namedtuple
collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
-
返回一个新的元组子类,名字为typename
-
field_names:一个像
[‘x’, ‘y’]
一样的字符串序列。另外 field_names 可以是一个纯字符串,用空白或逗号分隔开元素名,比如'x y'
或者'x, y'
。 -
例子
>>> # 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) 33 >>> x, y = p # unpack like a regular tuple >>> x, y (11, 22) >>> p.x + p.y # fields also accessible by name 33 >>> p # readable __repr__ with a name=value style Point(x=11, y=22)
除了继承元组的方法,命名元组还支持三个额外的方法和两个属性。为了防止字段名冲突,方法和属性以下划线开始。
nt._make(iterable)
类方法从存在的序列或迭代实例创建一个新实例。
>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)
nt._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())
。
nt._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())
nt._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)
nt.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')
11
转换一个字典到命名元组,使用 ** 两星操作符 (所述如 解包实参列表):
>>> d = {'x': 11, 'y': 22}
>>> Point(**d)
Point(x=11, y=22)
2. deque
class collections.deque([iterable[, maxlen]])
-
返回一个新的双向队列对象,从左到右初始化(用方法
append()
,从 iterable (迭代对象) 数据创建。如果 iterable 没有指定,新队列为空。Deque 支持线程安全,内存高效添加(append)和弹出(pop),从两端都可以,两个方向的大概开销都是 O(1) 复杂度。 -
虽然
list
对象也支持类似操作,不过这里优化了定长操作和pop(0)
和insert(0, v)
的开销。它们引起 O(n) 内存移动的操作,改变底层数据表达的大小和位置。 -
如果**
maxlen
**没有指定或者是None
,deques 可以增长到任意长度。否则,deque就限定到指定最大长度。一旦限定长度的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
。
队列支持的其他操作
除了以上操作,deque 还支持迭代、封存、len(d)
、reversed(d)
、copy.copy(d)
、copy.deepcopy(d)
、成员检测运算符 in
以及下标引用例如通过 d[0]
访问首个元素等。 索引访问在两端的复杂度均为 O(1) 但在中间则会低至 O(n)。 如需快速随机访问,请改用列表。
示例
>>> 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())
G
H
I
>>> 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 "<pyshell#6>", 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'])
3. Counter
class collections.Counter([iterable-or-mapping])
一个 Counter
是一个 dict
的子类,用于计数可哈希对象。它是一个集合,元素像字典键(key)一样存储,它们的计数存储为值。计数可以是任何整数值,包括0和负数。 Counter
类有点像其他语言中的 bags或multisets。
元素从一个 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
设置一个计数为0不会从计数器中移去一个元素。使用 del
来删除它:
>>> c['sausage'] = 0 # counter entry with a zero count
>>> del c['sausage'] # del actually removes the entry
在 3.7 版更改: 作为 dict
的子类,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()
从 迭代对象 或 映射对象 减去元素。像 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})
update()
从 迭代对象 计数元素或者 从另一个 映射对象 (或计数器) 添加。 但是字典的用法 dict.update()
是替换,而不是加上。另外,迭代对象 应该是序列元素,而不是一个 (key, value)
对。
>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c.update(d)
>>> c
Counter({'a': 4, 'b': 3})
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 # 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})
单目加和减(一元操作符)意思是从空计数器加或者减去。
>>> c = Counter(a=2, b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})
4. OrdereDict
有序词典就像常规词典一样,但有一些与排序操作相关的额外功能。由于内置的 dict
类获得了记住插入顺序的能力(在 Python 3.7 中保证了这种新行为),它们变得不那么重要了。
popitem(last)
有序字典移出一个(key-value
)键-值对,该方法的参数默认为last=True
,此时遵循后进先出(LIFO)的规则,否则为先进先出(FIFO)。
move_to_end(key, last)
将现有的key
移到有序字典的任意一端,默认last=True
,即将key
移到末尾;如果last=False
,则将key
移至首位。
reversed
有序词典还为键-值
提供逆序操作。
>>> d
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> d.values()
odict_values([1, 2, 3])
>>> reversed(d.values())
<odict_iterator object at 0x7feba6ade7d0>
>>> for i in reversed(d.values()):
... print(i)
...
3
2
1
5. defaultdict
一般的字典dict
,如果字典本身不包含某个键,而此时如果对这个键对应的值进行操作,会引发错误。例如:
>>> d = dict()
>>> d['name'] = 'Lyons' # 如果只是赋值,那没问题
>>> d['age'] += 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'age'
如果使用defaultdict来创建字典,可以提前告诉字典中的键对应的值是什么类型,当键不存在的时候,它也不会报错,而会设置一个默认值。
>>> from collections import defaultdict
>>> dd = defaultdict(int) # 如果是int型,会默认为0
>>> dd['age'] += 1
>>> dd
defaultdict(<class 'int'>, {'age': 1})
- 相应的如果是
list
类型,默认值是[]