`collections` — 容器数据类型 ¶

此模块实现专用容器数据类型，提供备选为 Python 一般目的内置容器 dict , list , set ，和 tuple .

`namedtuple()`	采用命名字段创建 tuple 子类的工厂函数
`deque`	两端都能快速追加和弹出的像 list 容器
`ChainMap`	用于创建多映射的单个视图的像 dict 类
`Counter`	用于计数可哈希对象的 dict 子类
`OrderedDict`	能记住条目添加次序的 dict 子类
`defaultdict`	调用工厂函数以提供缺少值的 dict 子类
`UserDict`	围绕字典对象的包裹器为更易于 dict 子类化
`UserList`	围绕列表对象的包裹器，为更容易 list 子类化
`UserString`	围绕字符串对象的包裹器为更易于字符串子类化

从 3.3 版起弃用，将在 3.10 版中移除：移动集合抽象基类到 collections.abc 模块。为向后兼容，它们在此模块中继续可见直到 Python 3.9。

`ChainMap` 对象 ¶

3.3 版新增。

A ChainMap 类是为快速链接很多映射而提供的，因此可以将它们视为单个单元。它通常快得多，比创建新字典并运行多个 update() 调用。

此类可以用于模拟嵌套作用域，且在模板中很有用。

class collections. ChainMap ( *maps ) ¶

maps ¶

new_child ( m=None ) ¶

parents ¶

This gives the same ordering as a series of dict.update() calls starting with the last mapping:

>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']

另请参阅

The MultiContext 类 in the Enthought CodeTools 包 has options to support writing to any mapping in the chain.
Django 的 Context 类 for templating is a read-only chain of mappings. It also features pushing and popping of contexts similar to the new_child() 方法和 parents 特性。
The 嵌套上下文配方 has options to control whether writes and other mutations apply only to the first mapping or to any mapping in the chain.
A greatly simplified read-only version of Chainmap .

`ChainMap` 范例和配方 ¶

This section shows various approaches to working with chained maps.

Example of simulating Python’s internal lookup chain:

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

Example of letting user specified command-line arguments take precedence over environment variables which in turn take precedence over default values:

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

Example patterns for using the ChainMap class to simulate nested contexts:

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

The ChainMap class only makes updates (writes and deletions) to the first mapping in the chain while lookups will search the full chain. However, if deep writes and deletions are desired, it is easy to make a subclass that updates keys found deeper in the chain:

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 ] ) ¶

elements ( ) ¶

most_common ( [ n ] ) ¶

subtract ( [ iterable-or-mapping ] ) ¶

fromkeys ( iterable ) ¶

update ( [ iterable-or-mapping ] ) ¶

`deque` 对象 ¶

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

append ( x ) ¶

appendleft ( x ) ¶

clear ( ) ¶

copy ( ) ¶

count ( x ) ¶

extend ( iterable ) ¶

extendleft ( iterable ) ¶

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

insert ( i , x ) ¶

pop ( ) ¶

popleft ( ) ¶

remove ( value ) ¶

reverse ( ) ¶

rotate ( n=1 ) ¶

maxlen ¶

class collections. defaultdict ( [ default_factory [ , ... ] ] ) ¶

__missing__ ( key ) ¶

default_factory ¶

`defaultdict` 范例 ¶

使用 list 作为 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)
...
>>> sorted(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 。 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)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

设置 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
...
>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

When a letter is first encountered, it is missing from the mapping, so the default_factory 函数调用 int() to supply a default count of zero. The increment operation then builds up the count for each letter.

函数 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 a lambda function which can supply any constant value (not just zero):

>>> def constant_factory(value):
...     return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
'John ran to <missing>'

设置 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)
...
>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

`namedtuple()` 用于带命名字段的元组的工厂函数 ¶

命名元组将含义赋值给元组中的每个位置，且允许更可读、自文档化代码。它们可以用于任何使用常规元组的地方，且通过名称而不是位置索引添加访问字段的能力。

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

>>> # 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)

命名元组尤其有用，把字段名赋值给结果元组返回通过 csv or 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)

从元组继承的方法除外，命名元组还支持 3 方法和 2 属性。为防止与字段名冲突，方法和属性名以下划线开头。

classmethod somenamedtuple. _make ( iterable ) ¶

somenamedtuple. _asdict ( ) ¶

somenamedtuple. _replace ( **kwargs ) ¶

somenamedtuple. _fields ¶

somenamedtuple. _field_defaults ¶

3.5 版改变：特性 docstring (文档字符串) 变为可写。

另请参阅

见 typing.NamedTuple for a way to add type hints for named tuples. It also provides an elegant notation using the class 关键词：

class Component(NamedTuple):
    part_number: int
    weight: float
    description: Optional[str] = None

见 types.SimpleNamespace() for a mutable namespace based on an underlying dictionary instead of a tuple.
The dataclasses module provides a decorator and functions for automatically adding generated special methods to user-defined classes.

`OrderedDict` 对象 ¶

有序字典就像普通字典，但拥有一些排序操作相关的额外能力。现在它们变得不太重要了，内置 dict 类获得了记住插入次序的能力 (这种新行为在 Python 3.7 获得保证)。

一些差异同 dict 仍然保留：

常规 dict 被设计成非常擅长映射操作。追踪插入次序是次要的。
The OrderedDict 被设计成很擅长重新排序操作。空间效率、迭代速度及更新操作的性能，是次要的。
从算法上讲， OrderedDict 可以更好地处理频繁重新排序操作相比 dict 。这使之适于追踪最近访问 (例如用于 LRU (最近最少使用) 缓存 ).
相等运算对于 OrderedDict 会校验匹配次序。
The popitem() 方法为 OrderedDict 有不同的签名。它接受可选自变量以指定弹出哪项。
OrderedDict 拥有 move_to_end() 方法以高效将元素重新定位到端点。
直到 Python 3.8， dict 缺乏 __reversed__() 方法。

class collections. OrderedDict ( [ 项 ] ) ¶

popitem ( last=True ) ¶

move_to_end ( key , last=True ) ¶

class collections. UserDict ( [ initialdata ] ) ¶

data ¶

`UserList` 对象 ¶

This class acts as a wrapper around list objects. It is a useful base class for your own list-like classes which can inherit from them and override existing methods or add new ones. In this way, one can add new behaviors to lists.

The need for this class has been partially supplanted by the ability to subclass directly from list ; however, this class can be easier to work with because the underlying list is accessible as an attribute.

class collections. UserList ( [ list ] ) ¶

data ¶

class collections. UserString ( seq ) ¶

data ¶

`collections` — 容器数据类型 ¶

`ChainMap` 对象 ¶

`ChainMap` 范例和配方 ¶

`Counter` 对象 ¶

`deque` 对象 ¶

`deque` 配方 ¶

`defaultdict` 对象 ¶

`defaultdict` 范例 ¶

`namedtuple()` 用于带命名字段的元组的工厂函数 ¶

`OrderedDict` 对象 ¶

`OrderedDict` 范例和配方 ¶

`UserDict` 对象 ¶

`UserList` 对象 ¶

`UserString` 对象 ¶

内容表

上一话题

下一话题

本页

快速搜索

collections — 容器数据类型 ¶

ChainMap 对象 ¶

ChainMap 范例和配方 ¶

Counter 对象 ¶

deque 对象 ¶

deque 配方 ¶

defaultdict 对象 ¶

defaultdict 范例 ¶

namedtuple() 用于带命名字段的元组的工厂函数 ¶

OrderedDict 对象 ¶

OrderedDict 范例和配方 ¶

UserDict 对象 ¶

UserList 对象 ¶

UserString 对象 ¶

内容表

上一话题

下一话题

本页

快速搜索

`collections` — 容器数据类型 ¶

`ChainMap` 对象 ¶

`ChainMap` 范例和配方 ¶

`Counter` 对象 ¶

`deque` 对象 ¶

`deque` 配方 ¶

`defaultdict` 对象 ¶

`defaultdict` 范例 ¶

`namedtuple()` 用于带命名字段的元组的工厂函数 ¶

`OrderedDict` 对象 ¶

`OrderedDict` 范例和配方 ¶

`UserDict` 对象 ¶

`UserList` 对象 ¶

`UserString` 对象 ¶