### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](collections.abc.xhtml "collections.abc --- 容器的抽象基类") |
- [上一页](calendar.xhtml "calendar --- General calendar-related functions") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 标准库](index.xhtml) »
- [数据类型](datatypes.xhtml) »
- $('.inline-search').show(0); |
# [`collections`](#module-collections "collections: Container datatypes") --- 容器数据类型
**Source code:** [Lib/collections/\_\_init\_\_.py](https://github.com/python/cpython/tree/3.7/Lib/collections/__init__.py) \[https://github.com/python/cpython/tree/3.7/Lib/collections/\_\_init\_\_.py\]
- - - - - -
这个模块实现了特定目标的容器，以提供Python标准内建容器 [`dict`](stdtypes.xhtml#dict "dict") , [`list`](stdtypes.xhtml#list "list") , [`set`](stdtypes.xhtml#set "set") , 和 [`tuple`](stdtypes.xhtml#tuple "tuple") 的替代选择。
[`namedtuple()`](#collections.namedtuple "collections.namedtuple")
创建命名元组子类的工厂函数
[`deque`](#collections.deque "collections.deque")
类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)
[`ChainMap`](#collections.ChainMap "collections.ChainMap")
类似字典(dict)的容器类，将多个映射集合到一个视图里面
[`Counter`](#collections.Counter "collections.Counter")
字典的子类，提供了可哈希对象的计数功能
[`OrderedDict`](#collections.OrderedDict "collections.OrderedDict")
字典的子类，保存了他们被添加的顺序
[`defaultdict`](#collections.defaultdict "collections.defaultdict")
字典的子类，提供了一个工厂函数，为字典查询提供一个默认值
[`UserDict`](#collections.UserDict "collections.UserDict")
封装了字典对象，简化了字典子类化
[`UserList`](#collections.UserList "collections.UserList")
封装了列表对象，简化了列表子类化
[`UserString`](#collections.UserString "collections.UserString")
封装了列表对象，简化了字符串子类化
在 3.3 版更改: 将 [Collections Abstract Base Classes](collections.abc.xhtml#collections-abstract-base-classes) 移到了 [`collections.abc`](collections.abc.xhtml#module-collections.abc "collections.abc: Abstract base classes for containers") 模块. 在Python 3.7 为了保持兼容性，他们依然在这个模块可见。最终会被全部移除掉。
## [`ChainMap`](#collections.ChainMap "collections.ChainMap") 对象
3\.3 新版功能.
一个 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 类是为了将多个映射快速的链接到一起，这样它们就可以作为一个单元处理。它通常比创建一个新字典和多次调用 [`update()`](stdtypes.xhtml#dict.update "dict.update") 要快很多。
这个类可以用于模拟嵌套作用域，并且在模版化的时候比较有用。
*class* `collections.``ChainMap`(*\*maps*)一个 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。 如果没有 *maps* 被指定，就提供一个默认的空字典，这样一个新链至少有一个映射。
底层映射被存储在一个列表中。这个列表是公开的，可以通过 *maps* 属性存取和更新。没有其他的状态。
搜索查询底层映射，直到一个键被找到。不同的是，写，更新和删除只操作第一个映射。
一个 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 通过引用合并底层映射。 所以，如果一个底层映射更新了，这些更改会反映到 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 。
支持所有常用字典方法。另外还有一个 *maps* 属性(attribute)，一个创建子上下文的方法(method)， 一个存取它们首个映射的属性(property):
`maps`一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，可以被修改。列表最少包含一个映射。
`new_child`(*m=None*)返回一个新的 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 类，包含了一个新映射(map)，后面跟随当前实例的全部映射(map)。如果 `m` 被指定，它就成为不同新的实例，就是在所有映射前加上 m，如果没有指定，就加上一个空字典，这样的话一个 `d.new_child()` 调用等价于 `ChainMap({}, *d.maps)` 。这个方法用于创建子上下文，不改变任何父映射的值。
在 3.4 版更改: 添加了 `m` 可选参数。
`parents`属性返回一个新的 [`ChainMap`](#collections.ChainMap "collections.ChainMap") 包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。 使用的场景类似在 [nested scopes](../glossary.xhtml#term-nested-scope) 嵌套作用域中使用 [`nonlocal`](../reference/simple_stmts.xhtml#nonlocal) 关键词。用例也可以类比内建函数 [`super()`](functions.xhtml#super "super") 。一个 `d.parents` 的引用等价于 `ChainMap(*d.maps[1:])` 。
注意，一个 [`ChainMap()`](#collections.ChainMap "collections.ChainMap") 的迭代顺序是通过扫描最后的映射来确定的:
```
>>> baseline = {'music': 'bach', 'art': 'rembrandt'}
>>> adjustments = {'art': 'van gogh', 'opera': 'carmen'}
>>> list(ChainMap(adjustments, baseline))
['music', 'art', 'opera']
```
这给出了与 [`dict.update()`](stdtypes.xhtml#dict.update "dict.update") 调用序列相同的顺序，从最后一个映射开始:
```
>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']
```
参见
- [MultiContext class](https://github.com/enthought/codetools/blob/4.0.0/codetools/contexts/multi_context.py) \[https://github.com/enthought/codetools/blob/4.0.0/codetools/contexts/multi\_context.py\] 在 Enthought [CodeTools package](https://github.com/enthought/codetools) \[https://github.com/enthought/codetools\] 有支持写映射的选项。
- Django 的 [Context class](https://github.com/django/django/blob/master/django/template/context.py) \[https://github.com/django/django/blob/master/django/template/context.py\] 模版是只读映射。它的上下文的push和pop特性也类似于 [`new_child()`](#collections.ChainMap.new_child "collections.ChainMap.new_child") 方法 [`parents`](#collections.ChainMap.parents "collections.ChainMap.parents") 属性。
- [Nested Contexts recipe](https://code.activestate.com/recipes/577434/) \[https://code.activestate.com/recipes/577434/\] 提供了是否对第一个映射或其他映射进行写和其他修改的选项。
- 一个 [极简的只读版 Chainmap](https://code.activestate.com/recipes/305268/) \[https://code.activestate.com/recipes/305268/\].
### [`ChainMap`](#collections.ChainMap "collections.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}
combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])
```
用 [`ChainMap`](#collections.ChainMap "collections.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`](#collections.ChainMap "collections.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`](#collections.Counter "collections.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`](#collections.Counter "collections.Counter") 是一个 [`dict`](stdtypes.xhtml#dict "dict") 的子类，用于计数可哈希对象。它是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数。 [`Counter`](#collections.Counter "collections.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`](exceptions.xhtml#KeyError "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\.1 新版功能.
计数器对象除了字典方法以外，还提供了三个其他的方法：
`elements`()返回一个迭代器，每个元素重复计数的个数。元素顺序是任意的。如果一个元素的计数小于1， [`elements()`](#collections.Counter.elements "collections.Counter.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()`](#collections.Counter.most_common "collections.Counter.most_common") 返回计数器中的 *所有* 元素。相等个数的元素顺序随机：
```
>>> Counter('abracadabra').most_common(3) # doctest: +SKIP
[('a', 5), ('r', 2), ('b', 2)]
```
`subtract`(\[*iterable-or-mapping*\])从 *迭代对象* 或 *映射对象* 减去元素。像 [`dict.update()`](stdtypes.xhtml#dict.update "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 新版功能.
通常字典方法都可用于 [`Counter`](#collections.Counter "collections.Counter") 对象，除了有两个方法工作方式与字典并不相同。
`fromkeys`(*iterable*)这个类方法没有在 [`Counter`](#collections.Counter "collections.Counter") 中实现。
`update`(\[*iterable-or-mapping*\])从 *迭代对象* 计数元素或者 从另一个 *映射对象* (或计数器) 添加。 像 [`dict.update()`](stdtypes.xhtml#dict.update "dict.update") 但是是加上，而不是替换。另外，*迭代对象* 应该是序列元素，而不是一个 `(key, value)` 对。
[`Counter`](#collections.Counter "collections.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`](#collections.Counter "collections.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]) # doctest: +SKIP
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})
```
3\.3 新版功能: 添加了对一元加，一元减和位置集合操作的支持。
注解
计数器主要是为了表达运行的正的计数而设计；但是，小心不要预先排除负数或者其他类型。为了帮助这些用例，这一节记录了最小范围和类型限制。
- [`Counter`](#collections.Counter "collections.Counter") 类是一个字典的子类，不限制键和值。值用于表示计数，但你实际上 *可以* 存储任何其他值。
- [`most_common()`](#collections.Counter.most_common "collections.Counter.most_common") 方法在值需要排序的时候用。
- 原地操作比如 `c[key] += 1` ， 值类型只需要支持加和减。 所以分数，小数，和十进制都可以用，负值也可以支持。这两个方法 [`update()`](#collections.Counter.update "collections.Counter.update") 和 [`subtract()`](#collections.Counter.subtract "collections.Counter.subtract") 的输入和输出也一样支持负数和0。
- Multiset多集合方法只为正值的使用情况设计。输入可以是负数或者0，但只输出计数为正的值。没有类型限制，但值类型需要支持加，减和比较操作。
- [`elements()`](#collections.Counter.elements "collections.Counter.elements") 方法要求正整数计数。忽略0和负数计数。
参见
- [Bag class](https://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html) \[https://www.gnu.org/software/smalltalk/manual-base/html\_node/Bag.html\] 在 Smalltalk。
- Wikipedia 链接 [Multisets](https://en.wikipedia.org/wiki/Multiset) \[https://en.wikipedia.org/wiki/Multiset\].
- [C++ multisets](http://www.java2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm) \[http://www.java2s.com/Tutorial/Cpp/0380\_\_set-multiset/Catalog0380\_\_set-multiset.htm\] 教程和例子。
- 数学操作和多集合用例，参考 *Knuth, Donald. The Art of Computer Programming Volume II, Section 4.6.3, Exercise 19* 。
- 在给定数量和集合元素枚举所有不同的多集合，参考 [`itertools.combinations_with_replacement()`](itertools.xhtml#itertools.combinations_with_replacement "itertools.combinations_with_replacement")
```
map(Counter, combinations_with_replacement('ABC', 2)) # --> AA AB AC BB BC CC
```
## [`deque`](#collections.deque "collections.deque") 对象
*class* `collections.``deque`(\[*iterable*\[, *maxlen*\]\])返回一个新的双向队列对象，从左到右初始化(用方法 [`append()`](#collections.deque.append "collections.deque.append")) ，从 *iterable* （迭代对象) 数据创建。如果 *iterable* 没有指定，新队列为空。
Deque队列是由栈或者queue队列生成的（发音是 “deck”，”double-ended queue”的简称）。Deque 支持线程安全，内存高效添加(append)和弹出(pop)，从两端都可以，两个方向的大概开销都是 O(1) 复杂度。
虽然 [`list`](stdtypes.xhtml#list "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* 个元素（从 *start* 开始计算，在 *stop* 之前）。返回第一个匹配，如果没找到的话，升起 [`ValueError`](exceptions.xhtml#ValueError "ValueError") 。
3\.5 新版功能.
`insert`(*i*, *x*)在位置 *i* 插入 *x* 。
如果插入会导致一个限长deque超出长度 *maxlen* 的话，就升起一个 [`IndexError`](exceptions.xhtml#IndexError "IndexError") 。
3\.5 新版功能.
`pop`()移去并且返回一个元素，deque最右侧的那一个。如果没有元素的话，就升起 [`IndexError`](exceptions.xhtml#IndexError "IndexError") 索引错误。
`popleft`()移去并且返回一个元素，deque最左侧的那一个。如果没有元素的话，就升起 [`IndexError`](exceptions.xhtml#IndexError "IndexError") 索引错误。
`remove`(*value*)移去找到的第一个 *value*。 如果没有的话就升起 [`ValueError`](exceptions.xhtml#ValueError "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`](../reference/expressions.xhtml#in) 操作符，和下标引用 `d[-1]` 。索引存取在两端的复杂度是 O(1)， 在中间的复杂度比 O(n) 略低。要快速存取，使用list来替代。
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())
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'])
```
### [`deque`](#collections.deque "collections.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
# 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 / n
```
一个 [轮询调度器](https://en.wikipedia.org/wiki/Round-robin_scheduling) \[https://en.wikipedia.org/wiki/Round-robin\_scheduling\] 可以通过在 [`deque`](#collections.deque "collections.deque") 中放入迭代器来实现。值从当前迭代器的位置0被取出并暂存(yield)。 如果这个迭代器消耗完毕，就用 [`popleft()`](#collections.deque.popleft "collections.deque.popleft") 将其从对列中移去；否则，就通过 [`rotate()`](#collections.deque.rotate "collections.deque.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()`](#collections.deque.rotate "collections.deque.rotate") 方法提供了一种方式来实现 [`deque`](#collections.deque "collections.deque") 切片和删除。 例如， 一个纯的Python `del d[n]` 实现依赖于 `rotate()` 来定位要弹出的元素
```
def delete_nth(d, n):
d.rotate(-n)
d.popleft()
d.rotate(n)
```
要实现 [`deque`](#collections.deque "collections.deque") 切片， 使用一个类似的方法，应用 [`rotate()`](#collections.deque.rotate "collections.deque.rotate") 将目标元素放到左边。通过 [`popleft()`](#collections.deque.popleft "collections.deque.popleft") 移去老的条目（entries），通过 [`extend()`](#collections.deque.extend "collections.deque.extend") 添加新的条目， 然后反向 rotate。这个方法可以最小代价实现命令式的栈操作，诸如 `dup`, `drop`, `swap`, `over`, `pick`, `rot`, 和 `roll` 。
## [`defaultdict`](#collections.defaultdict "collections.defaultdict") 对象
*class* `collections.``defaultdict`(\[*default\_factory*\[, *...*\]\])返回一个新的类似字典的对象。 [`defaultdict`](#collections.defaultdict "collections.defaultdict") 是内置 [`dict`](stdtypes.xhtml#dict "dict") 类的子类。它重载了一个方法并添加了一个可写的实例变量。其余的功能与 [`dict`](stdtypes.xhtml#dict "dict") 类相同，此处不再重复说明。
第一个参数 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 提供了一个初始值。它默认为 `None` 。所有的其他参数都等同与 [`dict`](stdtypes.xhtml#dict "dict") 构建器中的参数对待，包括关键词参数。
[`defaultdict`](#collections.defaultdict "collections.defaultdict") 对象除了支持 [`dict`](stdtypes.xhtml#dict "dict") 的操作，还支持下面的方法作为扩展:
`__missing__`(*key*)如果 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 是 `None` ， 它就升起一个 [`KeyError`](exceptions.xhtml#KeyError "KeyError") 并将 *key* 作为参数。
如果 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 不为 `None` ， 它就会会被调用，不带参数，为 *key* 提供一个默认值， 这个值和 *key* 作为一个对被插入到字典中，并返回。
如果调用 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 升起了一个例外，这个例外就被扩散传递，不经过改变。
这个方法在查询键值失败时，会被 [`dict`](stdtypes.xhtml#dict "dict") 中的 [`__getitem__()`](../reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 调用。不管它是返回值或升起例外，都会被 [`__getitem__()`](../reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 传递。
注意 [`__missing__()`](#collections.defaultdict.__missing__ "collections.defaultdict.__missing__") *不会* 被 [`__getitem__()`](../reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 以外的其他方法调用。意思就是 `get()` 会向正常的dict那样返回 `None` ，而不是使用 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 。
[`defaultdict`](#collections.defaultdict "collections.defaultdict") 支持以下实例变量:
`default_factory`这个属性被 [`__missing__()`](#collections.defaultdict.__missing__ "collections.defaultdict.__missing__") 方法使用；它从构建器的第一个参数初始化，如果提供了的话，否则就是 `None` 。
### [`defaultdict`](#collections.defaultdict "collections.defaultdict") 例子
使用 [`list`](stdtypes.xhtml#list "list") 作为 [`default_factory`](#collections.defaultdict.default_factory "collections.defaultdict.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`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 方法，并返回一个空的 [`list`](stdtypes.xhtml#list "list") 。 `list.append()` 操作添加值到这个新的列表里。当键再次被存取时，就正常操作， `list.append()` 添加另一个值到列表中。这个计数比它的等价方法 [`dict.setdefault()`](stdtypes.xhtml#dict.setdefault "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`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 为 [`int`](functions.xhtml#int "int") ，使 [`defaultdict`](#collections.defaultdict "collections.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`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 调用 [`int()`](functions.xhtml#int "int") 来提供一个整数0作为默认值。自增操作然后建立对每个字母的计数。
函数 [`int()`](functions.xhtml#int "int") 总是返回0，是常数函数的特殊情况。一个更快和灵活的方法是使用lambda函数，可以提供任何常量值(不只是0):
```
>>> 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`](#collections.defaultdict.default_factory "collections.defaultdict.default_factory") 为 [`set`](stdtypes.xhtml#set "set") 使 [`defaultdict`](#collections.defaultdict "collections.defaultdict") 用于构建字典集合:
```
>>> 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 "collections.namedtuple") 命名元组的工厂函数
命名元组赋予每个位置一个含义，提供可读性和自文档性。它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。
`collections.``namedtuple`(*typename*, *field\_names*, *\**, *rename=False*, *defaults=None*, *module=None*)返回一个新的元组子类，名为 *typename* 。这个新的子类用于创建类元组的对象，可以通过域名来获取属性值，同样也可以通过索引和迭代获取值。子类实例同样有文档字符串（类名和域名）另外一个有用的 [`__repr__()`](../reference/datamodel.xhtml#object.__repr__ "object.__repr__") 方法，以 `name=value` 格式列明了元组内容。
*field\_names* 是一个像 `[‘x’, ‘y’]` 一样的字符串序列。另外 *field\_names* 可以是一个纯字符串，用空白或逗号分隔开元素名，比如 `'x y'` 或者 `'x, y'` 。
任何有效的Python 标识符都可以作为域名，除了下划线开头的那些。有效标识符由字母，数字，下划线组成，但首字母不能是数字或下划线，另外不能是关键词 [`keyword`](keyword.xhtml#module-keyword "keyword: Test whether a string is a keyword in Python.") 比如 *class*, *for*, *return*, *global*, *pass*, 或 *raise* 。
如果 *rename* 为真， 无效域名会自动转换成位置名。比如 `['abc', 'def', 'ghi', 'abc']` 转换成 `['abc', '_1', 'ghi', '_3']` ， 消除关键词 `def` 和重复域名 `abc` 。
*defaults* 可以为 `None` 或者是一个默认值的 [iterable](../glossary.xhtml#term-iterable) 。如果一个默认值域必须跟其他没有默认值的域在一起出现，*defaults* 就应用到最右边的参数。比如如果域名 `['x', 'y', 'z']` 和默认值 `(1, 2)` ，那么 `x` 就必须指定一个参数值 ，`y` 默认值 `1` ， `z` 默认值 `2` 。
如果 *module* 值有定义，命名元组的 `__module__` 属性值就被设置。
命名元组实例没有字典，所以它们要更轻量，并且占用更小内存。
在 3.1 版更改: 添加了对 *rename* 的支持。
在 3.6 版更改: *verbose* 和 *rename* 参数成为 [仅限关键字参数](../glossary.xhtml#keyword-only-parameter).
在 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)
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`](csv.xhtml#module-csv "csv: Write and read tabular data to and from delimited files.") [`sqlite3`](sqlite3.xhtml#module-sqlite3 "sqlite3: A DB-API 2.0 implementation using SQLite 3.x.") 模块返回的元组
```
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`](stdtypes.xhtml#dict "dict") ，它将字段名称映射到它们对应的值：
```
>>> p = Point(x=11, y=22)
>>> p._asdict()
OrderedDict([('x', 11), ('y', 22)])
```
在 3.1 版更改: 返回一个 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 而不是 [`dict`](stdtypes.xhtml#dict "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)
```
`somenamedtuple.``_field_defaults`默认值的字典。
```
>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._field_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)
```
要获取这个名字域的值，使用 [`getattr()`](functions.xhtml#getattr "getattr") 函数 :
```
>>> getattr(p, 'x')
11
```
要将字典转换为命名元组，请使用 `**` 运算符（如 [解包参数列表](../tutorial/controlflow.xhtml#tut-unpacking-arguments) 中所述）：
```
>>> 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`](#collections.somenamedtuple._fields "collections.somenamedtuple._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 版更改: 文档字符串属性变成可写。
默认值可以用 [`_replace()`](#collections.somenamedtuple._replace "collections.somenamedtuple._replace") 来实现， 通过自定义一个原型实例:
```
>>> Account = namedtuple('Account', 'owner balance transaction_count')
>>> default_account = Account('<owner name>', 0.0, 0)
>>> johns_account = default_account._replace(owner='John')
>>> janes_account = default_account._replace(owner='Jane')
```
参见
- 请参阅 [`typing.NamedTuple`](typing.xhtml#typing.NamedTuple "typing.NamedTuple") ，以获取为命名元组添加类型提示的方法。 它还使用 [`class`](../reference/compound_stmts.xhtml#class) 关键字提供了一种优雅的符号:
```
class Component(NamedTuple):
part_number: int
weight: float
description: Optional[str] = None
```
- 对于以字典为底层的可变域名， 参考 [`types.SimpleNamespace()`](types.xhtml#types.SimpleNamespace "types.SimpleNamespace") 。
- [`dataclasses`](dataclasses.xhtml#module-dataclasses "dataclasses: Generate special methods on user-defined classes.") 模块提供了一个装饰器和一些函数，用于自动将生成的特殊方法添加到用户定义的类中。
## [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 对象
有序词典就像常规词典一样，但有一些与排序操作相关的额外功能。由于内置的 [`dict`](stdtypes.xhtml#dict "dict") 类获得了记住插入顺序的能力（在 Python 3.7 中保证了这种新行为），它们变得不那么重要了。
一些与 [`dict`](stdtypes.xhtml#dict "dict") 的不同仍然存在：
- 常规的 [`dict`](stdtypes.xhtml#dict "dict") 被设计为非常擅长映射操作。 跟踪插入顺序是次要的。
- [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 旨在擅长重新排序操作。 空间效率、迭代速度和更新操作的性能是次要的。
- 算法上， [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 可以比 [`dict`](stdtypes.xhtml#dict "dict") 更好地处理频繁的重新排序操作。 这使其适用于跟踪最近的访问（例如在 [LRU cache](https://medium.com/@krishankantsinghal/my-first-blog-on-medium-583159139237) \[https://medium.com/@krishankantsinghal/my-first-blog-on-medium-583159139237\] 中）。
- 对于 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") ，相等操作检查匹配顺序。
- [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 类的 `popitem()` 方法有不同的签名。它接受一个可选参数来指定弹出哪个元素。
- [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 类有一个 `move_to_end()` 方法，可以有效地将元素移动到任一端。
- Python 3.8之前， [`dict`](stdtypes.xhtml#dict "dict") 缺少 [`__reversed__()`](../reference/datamodel.xhtml#object.__reversed__ "object.__reversed__") 方法。
*class* `collections.``OrderedDict`(\[*items*\])返回一个 [`dict`](stdtypes.xhtml#dict "dict") 子类的实例，它具有专门用于重新排列字典顺序的方法。
3\.1 新版功能.
`popitem`(*last=True*)有序字典的 [`popitem()`](#collections.OrderedDict.popitem "collections.OrderedDict.popitem") 方法移除并返回一个 (key, value) 键值对。 如果 *last* 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回键值对。
`move_to_end`(*key*, *last=True*)将现有 *key* 移动到有序字典的任一端。 如果 *last* 为真值（默认）则将元素移至末尾；如果 *last* 为假值则将元素移至开头。如果 *key* 不存在则会触发 [`KeyError`](exceptions.xhtml#KeyError "KeyError"):
```
>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'
```
3\.2 新版功能.
相对于通常的映射方法，有序字典还另外提供了逆序迭代的支持，通过 [`reversed()`](functions.xhtml#reversed "reversed") 。
[`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 之间的相等测试是顺序敏感的，实现为 `list(od1.items())==list(od2.items())` 。 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 对象和其他的 [`Mapping`](collections.abc.xhtml#collections.abc.Mapping "collections.abc.Mapping") 的相等测试，是顺序敏感的字典测试。这允许 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 替换为任何字典可以使用的场所。
在 3.5 版更改: [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 的项(item)，键(key)和值(value) [视图](../glossary.xhtml#term-dictionary-view) 现在支持逆序迭代，通过 [`reversed()`](functions.xhtml#reversed "reversed") 。
在 3.6 版更改: [**PEP 468**](https://www.python.org/dev/peps/pep-0468) \[https://www.python.org/dev/peps/pep-0468\] 赞成将关键词参数的顺序保留， 通过传递给 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 构造器和它的 `update()` 方法。
### [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 例子和用法
创建记住键值 *最后* 插入顺序的有序字典变体很简单。 如果新条目覆盖现有条目，则原始插入位置将更改并移至末尾:
```
class LastUpdatedOrderedDict(OrderedDict):
'Store items in the order the keys were last added'
def __setitem__(self, key, value):
super().__setitem__(key, value)
super().move_to_end(key)
```
一个 [`OrderedDict`](#collections.OrderedDict "collections.OrderedDict") 对于实现 [`functools.lru_cache()`](functools.xhtml#functools.lru_cache "functools.lru_cache") 的变体也很有用:
```
class LRU(OrderedDict):
'Limit size, evicting the least recently looked-up key when full'
def __init__(self, maxsize=128, *args, **kwds):
self.maxsize = maxsize
super().__init__(*args, **kwds)
def __getitem__(self, key):
value = super().__getitem__(key)
self.move_to_end(key)
return value
def __setitem__(self, key, value):
super().__setitem__(key, value)
if len(self) > self.maxsize:
oldest = next(iter(self))
del self[oldest]
```
## [`UserDict`](#collections.UserDict "collections.UserDict") 对象
[`UserDict`](#collections.UserDict "collections.UserDict") 类是用作字典对象的外包装。对这个类的需求已部分由直接创建 [`dict`](stdtypes.xhtml#dict "dict") 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的字典可以作为属性来访问。
*class* `collections.``UserDict`(\[*initialdata*\])模拟一个字典类。这个实例的内容保存为一个正常字典， 可以通过 [`UserDict`](#collections.UserDict "collections.UserDict") 实例的 [`data`](#collections.UserDict.data "collections.UserDict.data") 属性存取。如果提供了 *initialdata* 值， [`data`](#collections.UserDict.data "collections.UserDict.data") 就被初始化为它的内容；注意一个 *initialdata* 的引用不会被保留作为其他用途。
[`UserDict`](#collections.UserDict "collections.UserDict") 实例提供了以下属性作为扩展方法和操作的支持:
`data`一个真实的字典，用于保存 [`UserDict`](#collections.UserDict "collections.UserDict") 类的内容。
## [`UserList`](#collections.UserList "collections.UserList") 对象
这个类封装了列表对象。它是一个有用的基础类，对于你想自定义的类似列表的类，可以继承和覆盖现有的方法，也可以添加新的方法。这样我们可以对列表添加新的行为。
对这个类的需求已部分由直接创建 [`list`](stdtypes.xhtml#list "list") 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的列表可以作为属性来访问。
*class* `collections.``UserList`(\[*list*\])模拟一个列表。这个实例的内容被保存为一个正常列表，通过 [`UserList`](#collections.UserList "collections.UserList") 的 [`data`](#collections.UserList.data "collections.UserList.data") 属性存取。实例内容被初始化为一个 *list* 的copy，默认为 `[]` 空列表。 *list* 可以是迭代对象，比如一个Python列表，或者一个 [`UserList`](#collections.UserList "collections.UserList") 对象。
[`UserList`](#collections.UserList "collections.UserList") 提供了以下属性作为可变序列的方法和操作的扩展:
`data`一个 [`list`](stdtypes.xhtml#list "list") 对象用于存储 [`UserList`](#collections.UserList "collections.UserList") 的内容。
**子类化的要求:** [`UserList`](#collections.UserList "collections.UserList") 的子类需要提供一个构造器，可以无参数调用，或者一个参数调用。返回一个新序列的列表操作需要创建一个实现类的实例。它假定了构造器可以以一个参数进行调用，这个参数是一个序列对象，作为数据源。
如果一个分离的类不希望依照这个需求，所有的特殊方法就必须重写；请参照源代码进行修改。
## [`UserString`](#collections.UserString "collections.UserString") 对象
[`UserString`](#collections.UserString "collections.UserString") 类是用作字符串对象的外包装。对这个类的需求已部分由直接创建 [`str`](stdtypes.xhtml#str "str") 的子类的功能所替代；不过，这个类处理起来更容易，因为底层的字符串可以作为属性来访问。
*class* `collections.``UserString`(*seq*)模拟一个字符串对象。这个实例对象的内容保存为一个正常字符串，通过 [`UserString`](#collections.UserString "collections.UserString") 的 [`data`](#collections.UserString.data "collections.UserString.data") 属性存取。实例内容初始化设置为 *seq* 的copy。*seq* 参数可以是任何可通过内建 [`str()`](stdtypes.xhtml#str "str") 函数转换为字符串的对象。
[`UserString`](#collections.UserString "collections.UserString") 提供了以下属性作为字符串方法和操作的额外支持：
`data`一个真正的 [`str`](stdtypes.xhtml#str "str") 对象用来存放 [`UserString`](#collections.UserString "collections.UserString") 类的内容。
在 3.5 版更改: 新方法 `__getnewargs__`, `__rmod__`, `casefold`, `format_map`, `isprintable`, 和 `maketrans`。
### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](collections.abc.xhtml "collections.abc --- 容器的抽象基类") |
- [上一页](calendar.xhtml "calendar --- General calendar-related functions") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 标准库](index.xhtml) »
- [数据类型](datatypes.xhtml) »
- $('.inline-search').show(0); |
© [版权所有](../copyright.xhtml) 2001-2019, Python Software Foundation.
Python 软件基金会是一个非盈利组织。 [请捐助。](https://www.python.org/psf/donations/)
最后更新于 5月 21, 2019. [发现了问题](../bugs.xhtml)？
使用[Sphinx](http://sphinx.pocoo.org/)1.8.4 创建。
- Python文档内容
- Python 有什么新变化？
- Python 3.7 有什么新变化
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- C API 的改变
- 构建的改变
- 性能优化
- 其他 CPython 实现的改变
- 已弃用的 Python 行为
- 已弃用的 Python 模块、函数和方法
- 已弃用的 C API 函数和类型
- 平台支持的移除
- API 与特性的移除
- 移除的模块
- Windows 专属的改变
- 移植到 Python 3.7
- Python 3.7.1 中的重要变化
- Python 3.7.2 中的重要变化
- Python 3.6 有什么新变化A
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- 性能优化
- Build and C API Changes
- 其他改进
- 弃用
- 移除
- 移植到Python 3.6
- Python 3.6.2 中的重要变化
- Python 3.6.4 中的重要变化
- Python 3.6.5 中的重要变化
- Python 3.6.7 中的重要变化
- Python 3.5 有什么新变化
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- Other module-level changes
- 性能优化
- Build and C API Changes
- 弃用
- 移除
- Porting to Python 3.5
- Notable changes in Python 3.5.4
- What's New In Python 3.4
- 摘要 - 发布重点
- 新的特性
- 新增模块
- 改进的模块
- CPython Implementation Changes
- 弃用
- 移除
- Porting to Python 3.4
- Changed in 3.4.3
- What's New In Python 3.3
- 摘要 - 发布重点
- PEP 405: Virtual Environments
- PEP 420: Implicit Namespace Packages
- PEP 3118: New memoryview implementation and buffer protocol documentation
- PEP 393: Flexible String Representation
- PEP 397: Python Launcher for Windows
- PEP 3151: Reworking the OS and IO exception hierarchy
- PEP 380: Syntax for Delegating to a Subgenerator
- PEP 409: Suppressing exception context
- PEP 414: Explicit Unicode literals
- PEP 3155: Qualified name for classes and functions
- PEP 412: Key-Sharing Dictionary
- PEP 362: Function Signature Object
- PEP 421: Adding sys.implementation
- Using importlib as the Implementation of Import
- 其他语言特性修改
- A Finer-Grained Import Lock
- Builtin functions and types
- 新增模块
- 改进的模块
- 性能优化
- Build and C API Changes
- 弃用
- Porting to Python 3.3
- What's New In Python 3.2
- PEP 384: Defining a Stable ABI
- PEP 389: Argparse Command Line Parsing Module
- PEP 391: Dictionary Based Configuration for Logging
- PEP 3148: The concurrent.futures module
- PEP 3147: PYC Repository Directories
- PEP 3149: ABI Version Tagged .so Files
- PEP 3333: Python Web Server Gateway Interface v1.0.1
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- 多线程
- 性能优化
- Unicode
- Codecs
- 文档
- IDLE
- Code Repository
- Build and C API Changes
- Porting to Python 3.2
- What's New In Python 3.1
- PEP 372: Ordered Dictionaries
- PEP 378: Format Specifier for Thousands Separator
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- 性能优化
- IDLE
- Build and C API Changes
- Porting to Python 3.1
- What's New In Python 3.0
- Common Stumbling Blocks
- Overview Of Syntax Changes
- Changes Already Present In Python 2.6
- Library Changes
- PEP 3101: A New Approach To String Formatting
- Changes To Exceptions
- Miscellaneous Other Changes
- Build and C API Changes
- 性能
- Porting To Python 3.0
- What's New in Python 2.7
- The Future for Python 2.x
- Changes to the Handling of Deprecation Warnings
- Python 3.1 Features
- PEP 372: Adding an Ordered Dictionary to collections
- PEP 378: Format Specifier for Thousands Separator
- PEP 389: The argparse Module for Parsing Command Lines
- PEP 391: Dictionary-Based Configuration For Logging
- PEP 3106: Dictionary Views
- PEP 3137: The memoryview Object
- 其他语言特性修改
- New and Improved Modules
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.7
- New Features Added to Python 2.7 Maintenance Releases
- Acknowledgements
- Python 2.6 有什么新变化
- Python 3.0
- Changes to the Development Process
- PEP 343: The 'with' statement
- PEP 366: Explicit Relative Imports From a Main Module
- PEP 370: Per-user site-packages Directory
- PEP 371: The multiprocessing Package
- PEP 3101: Advanced String Formatting
- PEP 3105: print As a Function
- PEP 3110: Exception-Handling Changes
- PEP 3112: Byte Literals
- PEP 3116: New I/O Library
- PEP 3118: Revised Buffer Protocol
- PEP 3119: Abstract Base Classes
- PEP 3127: Integer Literal Support and Syntax
- PEP 3129: Class Decorators
- PEP 3141: A Type Hierarchy for Numbers
- 其他语言特性修改
- New and Improved Modules
- Deprecations and Removals
- Build and C API Changes
- Porting to Python 2.6
- Acknowledgements
- What's New in Python 2.5
- PEP 308: Conditional Expressions
- PEP 309: Partial Function Application
- PEP 314: Metadata for Python Software Packages v1.1
- PEP 328: Absolute and Relative Imports
- PEP 338: Executing Modules as Scripts
- PEP 341: Unified try/except/finally
- PEP 342: New Generator Features
- PEP 343: The 'with' statement
- PEP 352: Exceptions as New-Style Classes
- PEP 353: Using ssize_t as the index type
- PEP 357: The 'index' method
- 其他语言特性修改
- New, Improved, and Removed Modules
- Build and C API Changes
- Porting to Python 2.5
- Acknowledgements
- What's New in Python 2.4
- PEP 218: Built-In Set Objects
- PEP 237: Unifying Long Integers and Integers
- PEP 289: Generator Expressions
- PEP 292: Simpler String Substitutions
- PEP 318: Decorators for Functions and Methods
- PEP 322: Reverse Iteration
- PEP 324: New subprocess Module
- PEP 327: Decimal Data Type
- PEP 328: Multi-line Imports
- PEP 331: Locale-Independent Float/String Conversions
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- Build and C API Changes
- Porting to Python 2.4
- Acknowledgements
- What's New in Python 2.3
- PEP 218: A Standard Set Datatype
- PEP 255: Simple Generators
- PEP 263: Source Code Encodings
- PEP 273: Importing Modules from ZIP Archives
- PEP 277: Unicode file name support for Windows NT
- PEP 278: Universal Newline Support
- PEP 279: enumerate()
- PEP 282: The logging Package
- PEP 285: A Boolean Type
- PEP 293: Codec Error Handling Callbacks
- PEP 301: Package Index and Metadata for Distutils
- PEP 302: New Import Hooks
- PEP 305: Comma-separated Files
- PEP 307: Pickle Enhancements
- Extended Slices
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- Pymalloc: A Specialized Object Allocator
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.3
- Acknowledgements
- What's New in Python 2.2
- 概述
- PEPs 252 and 253: Type and Class Changes
- PEP 234: Iterators
- PEP 255: Simple Generators
- PEP 237: Unifying Long Integers and Integers
- PEP 238: Changing the Division Operator
- Unicode Changes
- PEP 227: Nested Scopes
- New and Improved Modules
- Interpreter Changes and Fixes
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.1
- 概述
- PEP 227: Nested Scopes
- PEP 236: future Directives
- PEP 207: Rich Comparisons
- PEP 230: Warning Framework
- PEP 229: New Build System
- PEP 205: Weak References
- PEP 232: Function Attributes
- PEP 235: Importing Modules on Case-Insensitive Platforms
- PEP 217: Interactive Display Hook
- PEP 208: New Coercion Model
- PEP 241: Metadata in Python Packages
- New and Improved Modules
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.0
- 概述
- What About Python 1.6?
- New Development Process
- Unicode
- 列表推导式
- Augmented Assignment
- 字符串的方法
- Garbage Collection of Cycles
- Other Core Changes
- Porting to 2.0
- Extending/Embedding Changes
- Distutils: Making Modules Easy to Install
- XML Modules
- Module changes
- New modules
- IDLE Improvements
- Deleted and Deprecated Modules
- Acknowledgements
- 更新日志
- Python 下一版
- Python 3.7.3 最终版
- Python 3.7.3 发布候选版 1
- Python 3.7.2 最终版
- Python 3.7.2 发布候选版 1
- Python 3.7.1 最终版
- Python 3.7.1 RC 2版本
- Python 3.7.1 发布候选版 1
- Python 3.7.0 正式版
- Python 3.7.0 release candidate 1
- Python 3.7.0 beta 5
- Python 3.7.0 beta 4
- Python 3.7.0 beta 3
- Python 3.7.0 beta 2
- Python 3.7.0 beta 1
- Python 3.7.0 alpha 4
- Python 3.7.0 alpha 3
- Python 3.7.0 alpha 2
- Python 3.7.0 alpha 1
- Python 3.6.6 final
- Python 3.6.6 RC 1
- Python 3.6.5 final
- Python 3.6.5 release candidate 1
- Python 3.6.4 final
- Python 3.6.4 release candidate 1
- Python 3.6.3 final
- Python 3.6.3 release candidate 1
- Python 3.6.2 final
- Python 3.6.2 release candidate 2
- Python 3.6.2 release candidate 1
- Python 3.6.1 final
- Python 3.6.1 release candidate 1
- Python 3.6.0 final
- Python 3.6.0 release candidate 2
- Python 3.6.0 release candidate 1
- Python 3.6.0 beta 4
- Python 3.6.0 beta 3
- Python 3.6.0 beta 2
- Python 3.6.0 beta 1
- Python 3.6.0 alpha 4
- Python 3.6.0 alpha 3
- Python 3.6.0 alpha 2
- Python 3.6.0 alpha 1
- Python 3.5.5 final
- Python 3.5.5 release candidate 1
- Python 3.5.4 final
- Python 3.5.4 release candidate 1
- Python 3.5.3 final
- Python 3.5.3 release candidate 1
- Python 3.5.2 final
- Python 3.5.2 release candidate 1
- Python 3.5.1 final
- Python 3.5.1 release candidate 1
- Python 3.5.0 final
- Python 3.5.0 release candidate 4
- Python 3.5.0 release candidate 3
- Python 3.5.0 release candidate 2
- Python 3.5.0 release candidate 1
- Python 3.5.0 beta 4
- Python 3.5.0 beta 3
- Python 3.5.0 beta 2
- Python 3.5.0 beta 1
- Python 3.5.0 alpha 4
- Python 3.5.0 alpha 3
- Python 3.5.0 alpha 2
- Python 3.5.0 alpha 1
- Python 教程
- 课前甜点
- 使用 Python 解释器
- 调用解释器
- 解释器的运行环境
- Python 的非正式介绍
- Python 作为计算器使用
- 走向编程的第一步
- 其他流程控制工具
- if 语句
- for 语句
- range() 函数
- break 和 continue 语句，以及循环中的 else 子句
- pass 语句
- 定义函数
- 函数定义的更多形式
- 小插曲：编码风格
- 数据结构
- 列表的更多特性
- del 语句
- 元组和序列
- 集合
- 字典
- 循环的技巧
- 深入条件控制
- 序列和其它类型的比较
- 模块
- 有关模块的更多信息
- 标准模块
- dir() 函数
- 包
- 输入输出
- 更漂亮的输出格式
- 读写文件
- 错误和异常
- 语法错误
- 异常
- 处理异常
- 抛出异常
- 用户自定义异常
- 定义清理操作
- 预定义的清理操作
- 类
- 名称和对象
- Python 作用域和命名空间
- 初探类
- 补充说明
- 继承
- 私有变量
- 杂项说明
- 迭代器
- 生成器
- 生成器表达式
- 标准库简介
- 操作系统接口
- 文件通配符
- 命令行参数
- 错误输出重定向和程序终止
- 字符串模式匹配
- 数学
- 互联网访问
- 日期和时间
- 数据压缩
- 性能测量
- 质量控制
- 自带电池
- 标准库简介 —— 第二部分
- 格式化输出
- 模板
- 使用二进制数据记录格式
- 多线程
- 日志
- 弱引用
- 用于操作列表的工具
- 十进制浮点运算
- 虚拟环境和包
- 概述
- 创建虚拟环境
- 使用pip管理包
- 接下来？
- 交互式编辑和编辑历史
- Tab 补全和编辑历史
- 默认交互式解释器的替代品
- 浮点算术：争议和限制
- 表示性错误
- 附录
- 交互模式
- 安装和使用 Python
- 命令行与环境
- 命令行
- 环境变量
- 在Unix平台中使用Python
- 获取最新版本的Python
- 构建Python
- 与Python相关的路径和文件
- 杂项
- 编辑器和集成开发环境
- 在Windows上使用 Python
- 完整安装程序
- Microsoft Store包
- nuget.org 安装包
- 可嵌入的包
- 替代捆绑包
- 配置Python
- 适用于Windows的Python启动器
- 查找模块
- 附加模块
- 在Windows上编译Python
- 其他平台
- 在苹果系统上使用 Python
- 获取和安装 MacPython
- IDE
- 安装额外的 Python 包
- Mac 上的图形界面编程
- 在 Mac 上分发 Python 应用程序
- 其他资源
- Python 语言参考
- 概述
- 其他实现
- 标注
- 词法分析
- 行结构
- 其他形符
- 标识符和关键字
- 字面值
- 运算符
- 分隔符
- 数据模型
- 对象、值与类型
- 标准类型层级结构
- 特殊方法名称
- 协程
- 执行模型
- 程序的结构
- 命名与绑定
- 异常
- 导入系统
- importlib
- 包
- 搜索
- 加载
- 基于路径的查找器
- 替换标准导入系统
- Package Relative Imports
- 有关 main 的特殊事项
- 开放问题项
- 参考文献
- 表达式
- 算术转换
- 原子
- 原型
- await 表达式
- 幂运算符
- 一元算术和位运算
- 二元算术运算符
- 移位运算
- 二元位运算
- 比较运算
- 布尔运算
- 条件表达式
- lambda 表达式
- 表达式列表
- 求值顺序
- 运算符优先级
- 简单语句
- 表达式语句
- 赋值语句
- assert 语句
- pass 语句
- del 语句
- return 语句
- yield 语句
- raise 语句
- break 语句
- continue 语句
- import 语句
- global 语句
- nonlocal 语句
- 复合语句
- if 语句
- while 语句
- for 语句
- try 语句
- with 语句
- 函数定义
- 类定义
- 协程
- 最高层级组件
- 完整的 Python 程序
- 文件输入
- 交互式输入
- 表达式输入
- 完整的语法规范
- Python 标准库
- 概述
- 可用性注释
- 内置函数
- 内置常量
- 由 site 模块添加的常量
- 内置类型
- 逻辑值检测
- 布尔运算 — and, or, not
- 比较
- 数字类型 — int, float, complex
- 迭代器类型
- 序列类型 — list, tuple, range
- 文本序列类型 — str
- 二进制序列类型 — bytes, bytearray, memoryview
- 集合类型 — set, frozenset
- 映射类型 — dict
- 上下文管理器类型
- 其他内置类型
- 特殊属性
- 内置异常
- 基类
- 具体异常
- 警告
- 异常层次结构
- 文本处理服务
- string — 常见的字符串操作
- re — 正则表达式操作
- 模块 difflib 是一个计算差异的助手
- textwrap — Text wrapping and filling
- unicodedata — Unicode 数据库
- stringprep — Internet String Preparation
- readline — GNU readline interface
- rlcompleter — GNU readline的完成函数
- 二进制数据服务
- struct — Interpret bytes as packed binary data
- codecs — Codec registry and base classes
- 数据类型
- datetime — 基础日期/时间数据类型
- calendar — General calendar-related functions
- collections — 容器数据类型
- collections.abc — 容器的抽象基类
- heapq — 堆队列算法
- bisect — Array bisection algorithm
- array — Efficient arrays of numeric values
- weakref — 弱引用
- types — Dynamic type creation and names for built-in types
- copy — 浅层 (shallow) 和深层 (deep) 复制操作
- pprint — 数据美化输出
- reprlib — Alternate repr() implementation
- enum — Support for enumerations
- 数字和数学模块
- numbers — 数字的抽象基类
- math — 数学函数
- cmath — Mathematical functions for complex numbers
- decimal — 十进制定点和浮点运算
- fractions — 分数
- random — 生成伪随机数
- statistics — Mathematical statistics functions
- 函数式编程模块
- itertools — 为高效循环而创建迭代器的函数
- functools — 高阶函数和可调用对象上的操作
- operator — 标准运算符替代函数
- 文件和目录访问
- pathlib — 面向对象的文件系统路径
- os.path — 常见路径操作
- fileinput — Iterate over lines from multiple input streams
- stat — Interpreting stat() results
- filecmp — File and Directory Comparisons
- tempfile — Generate temporary files and directories
- glob — Unix style pathname pattern expansion
- fnmatch — Unix filename pattern matching
- linecache — Random access to text lines
- shutil — High-level file operations
- macpath — Mac OS 9 路径操作函数
- 数据持久化
- pickle —— Python 对象序列化
- copyreg — Register pickle support functions
- shelve — Python object persistence
- marshal — Internal Python object serialization
- dbm — Interfaces to Unix “databases”
- sqlite3 — SQLite 数据库 DB-API 2.0 接口模块
- 数据压缩和存档
- zlib — 与 gzip 兼容的压缩
- gzip — 对 gzip 格式的支持
- bz2 — 对 bzip2 压缩算法的支持
- lzma — 用 LZMA 算法压缩
- zipfile — 在 ZIP 归档中工作
- tarfile — Read and write tar archive files
- 文件格式
- csv — CSV 文件读写
- configparser — Configuration file parser
- netrc — netrc file processing
- xdrlib — Encode and decode XDR data
- plistlib — Generate and parse Mac OS X .plist files
- 加密服务
- hashlib — 安全哈希与消息摘要
- hmac — 基于密钥的消息验证
- secrets — Generate secure random numbers for managing secrets
- 通用操作系统服务
- os — 操作系统接口模块
- io — 处理流的核心工具
- time — 时间的访问和转换
- argparse — 命令行选项、参数和子命令解析器
- getopt — C-style parser for command line options
- 模块 logging — Python 的日志记录工具
- logging.config — 日志记录配置
- logging.handlers — Logging handlers
- getpass — 便携式密码输入工具
- curses — 终端字符单元显示的处理
- curses.textpad — Text input widget for curses programs
- curses.ascii — Utilities for ASCII characters
- curses.panel — A panel stack extension for curses
- platform — Access to underlying platform's identifying data
- errno — Standard errno system symbols
- ctypes — Python 的外部函数库
- 并发执行
- threading — 基于线程的并行
- multiprocessing — 基于进程的并行
- concurrent 包
- concurrent.futures — 启动并行任务
- subprocess — 子进程管理
- sched — 事件调度器
- queue — 一个同步的队列类
- _thread — 底层多线程 API
- _dummy_thread — _thread 的替代模块
- dummy_threading — 可直接替代 threading 模块。
- contextvars — Context Variables
- Context Variables
- Manual Context Management
- asyncio support
- 网络和进程间通信
- asyncio — 异步 I/O
- socket — 底层网络接口
- ssl — TLS/SSL wrapper for socket objects
- select — Waiting for I/O completion
- selectors — 高级 I/O 复用库
- asyncore — 异步socket处理器
- asynchat — 异步 socket 指令/响应 处理器
- signal — Set handlers for asynchronous events
- mmap — Memory-mapped file support
- 互联网数据处理
- email — 电子邮件与 MIME 处理包
- json — JSON 编码和解码器
- mailcap — Mailcap file handling
- mailbox — Manipulate mailboxes in various formats
- mimetypes — Map filenames to MIME types
- base64 — Base16, Base32, Base64, Base85 数据编码
- binhex — 对binhex4文件进行编码和解码
- binascii — 二进制和 ASCII 码互转
- quopri — Encode and decode MIME quoted-printable data
- uu — Encode and decode uuencode files
- 结构化标记处理工具
- html — 超文本标记语言支持
- html.parser — 简单的 HTML 和 XHTML 解析器
- html.entities — HTML 一般实体的定义
- XML处理模块
- xml.etree.ElementTree — The ElementTree XML API
- xml.dom — The Document Object Model API
- xml.dom.minidom — Minimal DOM implementation
- xml.dom.pulldom — Support for building partial DOM trees
- xml.sax — Support for SAX2 parsers
- xml.sax.handler — Base classes for SAX handlers
- xml.sax.saxutils — SAX Utilities
- xml.sax.xmlreader — Interface for XML parsers
- xml.parsers.expat — Fast XML parsing using Expat
- 互联网协议和支持
- webbrowser — 方便的Web浏览器控制器
- cgi — Common Gateway Interface support
- cgitb — Traceback manager for CGI scripts
- wsgiref — WSGI Utilities and Reference Implementation
- urllib — URL 处理模块
- urllib.request — 用于打开 URL 的可扩展库
- urllib.response — Response classes used by urllib
- urllib.parse — Parse URLs into components
- urllib.error — Exception classes raised by urllib.request
- urllib.robotparser — Parser for robots.txt
- http — HTTP 模块
- http.client — HTTP协议客户端
- ftplib — FTP protocol client
- poplib — POP3 protocol client
- imaplib — IMAP4 protocol client
- nntplib — NNTP protocol client
- smtplib —SMTP协议客户端
- smtpd — SMTP Server
- telnetlib — Telnet client
- uuid — UUID objects according to RFC 4122
- socketserver — A framework for network servers
- http.server — HTTP 服务器
- http.cookies — HTTP state management
- http.cookiejar — Cookie handling for HTTP clients
- xmlrpc — XMLRPC 服务端与客户端模块
- xmlrpc.client — XML-RPC client access
- xmlrpc.server — Basic XML-RPC servers
- ipaddress — IPv4/IPv6 manipulation library
- 多媒体服务
- audioop — Manipulate raw audio data
- aifc — Read and write AIFF and AIFC files
- sunau — 读写 Sun AU 文件
- wave — 读写WAV格式文件
- chunk — Read IFF chunked data
- colorsys — Conversions between color systems
- imghdr — 推测图像类型
- sndhdr — 推测声音文件的类型
- ossaudiodev — Access to OSS-compatible audio devices
- 国际化
- gettext — 多语种国际化服务
- locale — 国际化服务
- 程序框架
- turtle — 海龟绘图
- cmd — 支持面向行的命令解释器
- shlex — Simple lexical analysis
- Tk图形用户界面(GUI)
- tkinter — Tcl/Tk的Python接口
- tkinter.ttk — Tk themed widgets
- tkinter.tix — Extension widgets for Tk
- tkinter.scrolledtext — 滚动文字控件
- IDLE
- 其他图形用户界面（GUI）包
- 开发工具
- typing — 类型标注支持
- pydoc — Documentation generator and online help system
- doctest — Test interactive Python examples
- unittest — 单元测试框架
- unittest.mock — mock object library
- unittest.mock 上手指南
- 2to3 - 自动将 Python 2 代码转为 Python 3 代码
- test — Regression tests package for Python
- test.support — Utilities for the Python test suite
- test.support.script_helper — Utilities for the Python execution tests
- 调试和分析
- bdb — Debugger framework
- faulthandler — Dump the Python traceback
- pdb — The Python Debugger
- The Python Profilers
- timeit — 测量小代码片段的执行时间
- trace — Trace or track Python statement execution
- tracemalloc — Trace memory allocations
- 软件打包和分发
- distutils — 构建和安装 Python 模块
- ensurepip — Bootstrapping the pip installer
- venv — 创建虚拟环境
- zipapp — Manage executable Python zip archives
- Python运行时服务
- sys — 系统相关的参数和函数
- sysconfig — Provide access to Python's configuration information
- builtins — 内建对象
- main — 顶层脚本环境
- warnings — Warning control
- dataclasses — 数据类
- contextlib — Utilities for with-statement contexts
- abc — 抽象基类
- atexit — 退出处理器
- traceback — Print or retrieve a stack traceback
- future — Future 语句定义
- gc — 垃圾回收器接口
- inspect — 检查对象
- site — Site-specific configuration hook
- 自定义 Python 解释器
- code — Interpreter base classes
- codeop — Compile Python code
- 导入模块
- zipimport — Import modules from Zip archives
- pkgutil — Package extension utility
- modulefinder — 查找脚本使用的模块
- runpy — Locating and executing Python modules
- importlib — The implementation of import
- Python 语言服务
- parser — Access Python parse trees
- ast — 抽象语法树
- symtable — Access to the compiler's symbol tables
- symbol — 与 Python 解析树一起使用的常量
- token — 与Python解析树一起使用的常量
- keyword — 检验Python关键字
- tokenize — Tokenizer for Python source
- tabnanny — 模糊缩进检测
- pyclbr — Python class browser support
- py_compile — Compile Python source files
- compileall — Byte-compile Python libraries
- dis — Python 字节码反汇编器
- pickletools — Tools for pickle developers
- 杂项服务
- formatter — Generic output formatting
- Windows系统相关模块
- msilib — Read and write Microsoft Installer files
- msvcrt — Useful routines from the MS VC++ runtime
- winreg — Windows 注册表访问
- winsound — Sound-playing interface for Windows
- Unix 专有服务
- posix — The most common POSIX system calls
- pwd — 用户密码数据库
- spwd — The shadow password database
- grp — The group database
- crypt — Function to check Unix passwords
- termios — POSIX style tty control
- tty — 终端控制功能
- pty — Pseudo-terminal utilities
- fcntl — The fcntl and ioctl system calls
- pipes — Interface to shell pipelines
- resource — Resource usage information
- nis — Interface to Sun's NIS (Yellow Pages)
- Unix syslog 库例程
- 被取代的模块
- optparse — Parser for command line options
- imp — Access the import internals
- 未创建文档的模块
- 平台特定模块
- 扩展和嵌入 Python 解释器
- 推荐的第三方工具
- 不使用第三方工具创建扩展
- 使用 C 或 C++ 扩展 Python
- 自定义扩展类型：教程
- 定义扩展类型：已分类主题
- 构建C/C++扩展
- 在Windows平台编译C和C++扩展
- 在更大的应用程序中嵌入 CPython 运行时
- Embedding Python in Another Application
- Python/C API 参考手册
- 概述
- 代码标准
- 包含文件
- 有用的宏
- 对象、类型和引用计数
- 异常
- 嵌入Python
- 调试构建
- 稳定的应用程序二进制接口
- The Very High Level Layer
- Reference Counting
- 异常处理
- Printing and clearing
- 抛出异常
- Issuing warnings
- Querying the error indicator
- Signal Handling
- Exception Classes
- Exception Objects
- Unicode Exception Objects
- Recursion Control
- 标准异常
- 标准警告类别
- 工具
- 操作系统实用程序
- 系统功能
- 过程控制
- 导入模块
- Data marshalling support
- 语句解释及变量编译
- 字符串转换与格式化
- 反射
- 编解码器注册与支持功能
- 抽象对象层
- Object Protocol
- 数字协议
- Sequence Protocol
- Mapping Protocol
- 迭代器协议
- 缓冲协议
- Old Buffer Protocol
- 具体的对象层
- 基本对象
- 数值对象
- 序列对象
- 容器对象
- 函数对象
- 其他对象
- Initialization, Finalization, and Threads
- 在Python初始化之前
- 全局配置变量
- Initializing and finalizing the interpreter
- Process-wide parameters
- Thread State and the Global Interpreter Lock
- Sub-interpreter support
- Asynchronous Notifications
- Profiling and Tracing
- Advanced Debugger Support
- Thread Local Storage Support
- 内存管理
- 概述
- 原始内存接口
- Memory Interface
- 对象分配器
- 默认内存分配器
- Customize Memory Allocators
- The pymalloc allocator
- tracemalloc C API
- 示例
- 对象实现支持
- 在堆中分配对象
- Common Object Structures
- Type 对象
- Number Object Structures
- Mapping Object Structures
- Sequence Object Structures
- Buffer Object Structures
- Async Object Structures
- 使对象类型支持循环垃圾回收
- API 和 ABI 版本管理
- 分发 Python 模块
- 关键术语
- 开源许可与协作
- 安装工具
- 阅读指南
- 我该如何...？
- ...为我的项目选择一个名字？
- ...创建和分发二进制扩展？
- 安装 Python 模块
- 关键术语
- 基本使用
- 我应如何 ...？
- ... 在 Python 3.4 之前的 Python 版本中安装 pip ？
- ... 只为当前用户安装软件包？
- ... 安装科学计算类 Python 软件包？
- ... 使用并行安装的多个 Python 版本？
- 常见的安装问题
- 在 Linux 的系统 Python 版本上安装
- 未安装 pip
- 安装二进制编译扩展
- Python 常用指引
- 将 Python 2 代码迁移到 Python 3
- 简要说明
- 详情
- 将扩展模块移植到 Python 3
- 条件编译
- 对象API的更改
- 模块初始化和状态
- CObject 替换为 Capsule
- 其他选项
- Curses Programming with Python
- What is curses?
- Starting and ending a curses application
- Windows and Pads
- Displaying Text
- User Input
- For More Information
- 实现描述器
- 摘要
- 定义和简介
- 描述器协议
- 发起调用描述符
- 描述符示例
- Properties
- 函数和方法
- Static Methods and Class Methods
- 函数式编程指引
- 概述
- 迭代器
- 生成器表达式和列表推导式
- 生成器
- 内置函数
- itertools 模块
- The functools module
- Small functions and the lambda expression
- Revision History and Acknowledgements
- 引用文献
- 日志 HOWTO
- 日志基础教程
- 进阶日志教程
- 日志级别
- 有用的处理程序
- 记录日志中引发的异常
- 使用任意对象作为消息
- 优化
- 日志操作手册
- 在多个模块中使用日志
- 在多线程中使用日志
- 使用多个日志处理器和多种格式化
- 在多个地方记录日志
- 日志服务器配置示例
- 处理日志处理器的阻塞
- Sending and receiving logging events across a network
- Adding contextual information to your logging output
- Logging to a single file from multiple processes
- Using file rotation
- Use of alternative formatting styles
- Customizing LogRecord
- Subclassing QueueHandler - a ZeroMQ example
- Subclassing QueueListener - a ZeroMQ example
- An example dictionary-based configuration
- Using a rotator and namer to customize log rotation processing
- A more elaborate multiprocessing example
- Inserting a BOM into messages sent to a SysLogHandler
- Implementing structured logging
- Customizing handlers with dictConfig()
- Using particular formatting styles throughout your application
- Configuring filters with dictConfig()
- Customized exception formatting
- Speaking logging messages
- Buffering logging messages and outputting them conditionally
- Formatting times using UTC (GMT) via configuration
- Using a context manager for selective logging
- 正则表达式HOWTO
- 概述
- 简单模式
- 使用正则表达式
- 更多模式能力
- 修改字符串
- 常见问题
- 反馈
- 套接字编程指南
- 套接字
- 创建套接字
- 使用一个套接字
- 断开连接
- 非阻塞的套接字
- 排序指南
- 基本排序
- 关键函数
- Operator 模块函数
- 升序和降序
- 排序稳定性和排序复杂度
- 使用装饰-排序-去装饰的旧方法
- 使用 cmp 参数的旧方法
- 其它
- Unicode 指南
- Unicode 概述
- Python's Unicode Support
- Reading and Writing Unicode Data
- Acknowledgements
- 如何使用urllib包获取网络资源
- 概述
- Fetching URLs
- 处理异常
- info and geturl
- Openers and Handlers
- Basic Authentication
- Proxies
- Sockets and Layers
- 脚注
- Argparse 教程
- 概念
- 基础
- 位置参数介绍
- Introducing Optional arguments
- Combining Positional and Optional arguments
- Getting a little more advanced
- Conclusion
- ipaddress模块介绍
- 创建 Address/Network/Interface 对象
- 审查 Address/Network/Interface 对象
- Network 作为 Address 列表
- 比较
- 将IP地址与其他模块一起使用
- 实例创建失败时获取更多详细信息
- Argument Clinic How-To
- The Goals Of Argument Clinic
- Basic Concepts And Usage
- Converting Your First Function
- Advanced Topics
- 使用 DTrace 和 SystemTap 检测CPython
- Enabling the static markers
- Static DTrace probes
- Static SystemTap markers
- Available static markers
- SystemTap Tapsets
- 示例
- Python 常见问题
- Python常见问题
- 一般信息
- 现实世界中的 Python
- 编程常见问题
- 一般问题
- 核心语言
- 数字和字符串
- 性能
- 序列（元组/列表）
- 对象
- 模块
- 设计和历史常见问题
- 为什么Python使用缩进来分组语句？
- 为什么简单的算术运算得到奇怪的结果？
- 为什么浮点计算不准确？
- 为什么Python字符串是不可变的？
- 为什么必须在方法定义和调用中显式使用“self”？
- 为什么不能在表达式中赋值？
- 为什么Python对某些功能（例如list.index()）使用方法来实现，而其他功能（例如len(List)）使用函数实现？
- 为什么 join()是一个字符串方法而不是列表或元组方法？
- 异常有多快？
- 为什么Python中没有switch或case语句？
- 难道不能在解释器中模拟线程，而非得依赖特定于操作系统的线程实现吗？
- 为什么lambda表达式不能包含语句？
- 可以将Python编译为机器代码，C或其他语言吗？
- Python如何管理内存？
- 为什么CPython不使用更传统的垃圾回收方案？
- CPython退出时为什么不释放所有内存？
- 为什么有单独的元组和列表数据类型？
- 列表是如何在CPython中实现的？
- 字典是如何在CPython中实现的？
- 为什么字典key必须是不可变的？
- 为什么 list.sort() 没有返回排序列表？
- 如何在Python中指定和实施接口规范？
- 为什么没有goto？
- 为什么原始字符串（r-strings）不能以反斜杠结尾？
- 为什么Python没有属性赋值的“with”语句？
- 为什么 if/while/def/class语句需要冒号？
- 为什么Python在列表和元组的末尾允许使用逗号？
- 代码库和插件 FAQ
- 通用的代码库问题
- 通用任务
- 线程相关
- 输入输出
- 网络 / Internet 编程
- 数据库
- 数学和数字
- 扩展/嵌入常见问题
- 可以使用C语言中创建自己的函数吗？
- 可以使用C++语言中创建自己的函数吗？
- C很难写，有没有其他选择？
- 如何从C执行任意Python语句？
- 如何从C中评估任意Python表达式？
- 如何从Python对象中提取C的值？
- 如何使用Py_BuildValue()创建任意长度的元组？
- 如何从C调用对象的方法？
- 如何捕获PyErr_Print()（或打印到stdout / stderr的任何内容）的输出？
- 如何从C访问用Python编写的模块？
- 如何从Python接口到C ++对象？
- 我使用Setup文件添加了一个模块，为什么make失败了？
- 如何调试扩展？
- 我想在Linux系统上编译一个Python模块，但是缺少一些文件。为什么?
- 如何区分“输入不完整”和“输入无效”？
- 如何找到未定义的g++符号__builtin_new或__pure_virtual？
- 能否创建一个对象类，其中部分方法在C中实现，而其他方法在Python中实现（例如通过继承）？
- Python在Windows上的常见问题
- 我怎样在Windows下运行一个Python程序？
- 我怎么让 Python 脚本可执行？
- 为什么有时候 Python 程序会启动缓慢？
- 我怎样使用Python脚本制作可执行文件？
- *.pyd 文件和DLL文件相同吗？
- 我怎样将Python嵌入一个Windows程序？
- 如何让编辑器不要在我的 Python 源代码中插入 tab ？
- 如何在不阻塞的情况下检查按键？
- 图形用户界面（GUI）常见问题
- 图形界面常见问题
- Python 是否有平台无关的图形界面工具包？
- 有哪些Python的GUI工具是某个平台专用的？
- 有关Tkinter的问题
- “为什么我的电脑上安装了 Python ？”
- 什么是Python？
- 为什么我的电脑上安装了 Python ？
- 我能删除 Python 吗？
- 术语对照表
- 文档说明
- Python 文档贡献者
- 解决 Bug
- 文档错误
- 使用 Python 的错误追踪系统
- 开始为 Python 贡献您的知识
- 版权
- 历史和许可证
- 软件历史
- 访问Python或以其他方式使用Python的条款和条件
- Python 3.7.3 的 PSF 许可协议
- Python 2.0 的 BeOpen.com 许可协议
- Python 1.6.1 的 CNRI 许可协议
- Python 0.9.0 至 1.2 的 CWI 许可协议
- 集成软件的许可和认可
- Mersenne Twister
- 套接字
- Asynchronous socket services
- Cookie management
- Execution tracing
- UUencode and UUdecode functions
- XML Remote Procedure Calls
- test_epoll
- Select kqueue
- SipHash24
- strtod and dtoa
- OpenSSL
- expat
- libffi
- zlib
- cfuhash
- libmpdec