### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](logging-cookbook.xhtml "日志操作手册") |
- [上一页](functional.xhtml "函数式编程指引") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 常用指引](index.xhtml) »
- $('.inline-search').show(0); |
# 日志 HOWTO
作者Vinay Sajip <vinay\_sajip at red-dove dot com>
## 日志基础教程
日志是对软件执行时所发生事件的一种追踪方式。软件开发人员对他们的代码添加日志调用，借此来指示某事件的发生。一个事件通过一些包含变量数据的描述信息来描述（比如：每个事件发生时的数据都是不同的）。开发者还会区分事件的重要性，重要性也被称为 *等级* 或 *严重性*
### 什么时候使用日志
对于简单的日志使用来说日志功能提供了一系列便利的函数。它们是 [`debug()`](../library/logging.xhtml#logging.debug "logging.debug")，[`info()`](../library/logging.xhtml#logging.info "logging.info")，[`warning()`](../library/logging.xhtml#logging.warning "logging.warning")，[`error()`](../library/logging.xhtml#logging.error "logging.error") 和 [`critical()`](../library/logging.xhtml#logging.critical "logging.critical")。想要决定何时使用日志，请看下表，其中显示了对于每个通用任务集合来说最好的工具。
你想要执行的任务
此任务的最好的工具
对于命令行或程序的应用，结果显示在控制台。
[`print()`](../library/functions.xhtml#print "print")
在对程序的普通操作发生时提交事件报告(比如：状态监控和错误调查)
[`logging.info()`](../library/logging.xhtml#logging.info "logging.info") 函数(当有诊断目的需要详细输出信息时使用 [`logging.debug()`](../library/logging.xhtml#logging.debug "logging.debug") 函数)
提出一个警告信息基于一个特殊的运行时事件
[`warnings.warn()`](../library/warnings.xhtml#warnings.warn "warnings.warn") 位于代码库中，该事件是可以避免的，需要修改客户端应用以消除告警
[`logging.warning()`](../library/logging.xhtml#logging.warning "logging.warning") 不需要修改客户端应用，但是该事件还是需要引起关注
对一个特殊的运行时事件报告错误
引发异常
报告错误而不引发异常(如在长时间运行中的服务端进程的错误处理)
[`logging.error()`](../library/logging.xhtml#logging.error "logging.error"), [`logging.exception()`](../library/logging.xhtml#logging.exception "logging.exception") 或 [`logging.critical()`](../library/logging.xhtml#logging.critical "logging.critical") 分别适用于特定的错误及应用领域
日志功能应以所追踪事件级别或严重性而定。各级别适用性如下（以严重性递增）：
级别
何时使用
`DEBUG`
细节信息，仅当诊断问题时适用。
`INFO`
确认程序按预期运行
`WARNING`
表明有已经或即将发生的意外（例如：磁盘空间不足）。程序仍按预期进行
`ERROR`
由于严重的问题，程序的某些功能已经不能正常执行
`CRITICAL`
严重的错误，表明程序已不能继续执行
默认的级别是``WARNING``，意味着只会追踪该级别及以上的事件，除非更改日志配置。
所追踪事件可以以不同形式处理。最简单的方式是输出到控制台。另一种常用的方式是写入磁盘文件。
### 一个简单的例子
一个非常简单的例子：
```
import logging
logging.warning('Watch out!') # will print a message to the console
logging.info('I told you so') # will not print anything
```
如果你在命令行中输入这些代码并运行，你将会看到：
```
WARNING:root:Watch out!
```
输出到命令行。`INFO` 消息并没有出现，因为默认级别是 `WARNING` 。打印的信息包含事件的级别以及在日志调用中的对于事件的描述，例如“Watch out!”。暂时不用担心“root”部分：之后会作出解释。输出格式可按需要进行调整，格式化选项同样会在之后作出解释。
### 记录日志到文件
一种非常常见的情况是将日志事件记录到文件，让我们继续往下看。请确认启动新的Python 解释器，不要在上一个环境中继续操作:
```
import logging
logging.basicConfig(filename='example.log',level=logging.DEBUG)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')
```
现在，如果我们打开日志文件，我们应当能看到日志信息：
```
DEBUG:root:This message should go to the log file
INFO:root:So should this
WARNING:root:And this, too
```
该示例同样展示了如何设置日志追踪级别的阈值。该示例中，由于我们设置的阈值是 `DEBUG`，所有信息全部打印
如果你想从命令行设置日志级别，例如：
```
--log=INFO
```
并且在一些 *loglevel* 变量中你可以获得 `--log` 命令的参数，你可以使用：
```
getattr(logging, loglevel.upper())
```
通过 *level* 参数获得你将传递给 [`basicConfig()`](../library/logging.xhtml#logging.basicConfig "logging.basicConfig") 的值。你需要对用户输入数据进行错误排查，可如下例：
```
# assuming loglevel is bound to the string value obtained from the
# command line argument. Convert to upper case to allow the user to
# specify --log=DEBUG or --log=debug
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % loglevel)
logging.basicConfig(level=numeric_level, ...)
```
对 [`basicConfig()`](../library/logging.xhtml#logging.basicConfig "logging.basicConfig") 的调用应该在 [`debug()`](../library/logging.xhtml#logging.debug "logging.debug") ， [`info()`](../library/logging.xhtml#logging.info "logging.info") 等的前面。因为它被设计为一次性的配置，只有第一次调用会进行操作，随后的调用不会产生有效操作。
如果多次运行上述脚本，则连续运行的消息将追加到文件 *example.log* 。 如果你希望每次运行重新开始，而不是记住先前运行的消息，则可以通过将上例中的调用更改为来指定 *filemode* 参数:
```
logging.basicConfig(filename='example.log', filemode='w', level=logging.DEBUG)
```
输出将与之前相同，但不再追加进日志文件，因此早期运行的消息将丢失。
### 从多个模块记录日志
如果你的程序包含多个模块，这里有一个如何组织日志记录的示例:
```
# myapp.py
import logging
import mylib
def main():
logging.basicConfig(filename='myapp.log', level=logging.INFO)
logging.info('Started')
mylib.do_something()
logging.info('Finished')
if __name__ == '__main__':
main()
```
```
# mylib.py
import logging
def do_something():
logging.info('Doing something')
```
如果你运行 *myapp.py* ，你应该在 *myapp.log* 中看到：
```
INFO:root:Started
INFO:root:Doing something
INFO:root:Finished
```
这是你期待看到的。 你可以使用 *mylib.py* 中的模式将此概括为多个模块。 请注意，对于这种简单的使用模式，除了查看事件描述之外，你不能通过查看日志文件来了解应用程序中消息的 *来源* 。 如果要跟踪消息的位置，则需要参考教程级别以外的文档 - 请参阅 [进阶日志教程](#logging-advanced-tutorial) 。
### 记录变量数据
要记录变量数据，请使用格式字符串作为事件描述消息，并将变量数据作为参数附加。 例如:
```
import logging
logging.warning('%s before you %s', 'Look', 'leap!')
```
将显示：
```
WARNING:root:Look before you leap!
```
如你所见，将可变数据合并到事件描述消息中使用旧的 %-s形式的字符串格式化。 这是为了向后兼容：logging 包的出现时间早于较新的格式化选项例如 [`str.format()`](../library/stdtypes.xhtml#str.format "str.format") 和 [`string.Template`](../library/string.xhtml#string.Template "string.Template")。 这些较新格式化选项 *是* 受支持的，但探索它们超出了本教程的范围：有关详细信息，请参阅 [Using particular formatting styles throughout your application](logging-cookbook.xhtml#formatting-styles)。
### 更改显示消息的格式
要更改用于显示消息的格式，你需要指定要使用的格式:
```
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
logging.debug('This message should appear on the console')
logging.info('So should this')
logging.warning('And this, too')
```
这将输出：
```
DEBUG:This message should appear on the console
INFO:So should this
WARNING:And this, too
```
请注意，前面示例中出现的“root”已消失。 对于可以出现在格式字符串中的全部内容，你可以参考以下文档 [LogRecord attributes](../library/logging.xhtml#logrecord-attributes) ，但为了简单使用，你只需要 *levelname* （严重性）， *message* （事件描述，包括可变数据），也许在事件发生时显示。 这将在下一节中介绍。
### 在消息中显示日期/时间
要显示事件的日期和时间，你可以在格式字符串中放置 '%(asctime)s'
```
import logging
logging.basicConfig(format='%(asctime)s %(message)s')
logging.warning('is when this event was logged.')
```
应该打印这样的东西：
```
2010-12-12 11:41:42,612 is when this event was logged.
```
日期/时间显示的默认格式（如上所示）类似于 ISO8601 或 [**RFC 3339**](https://tools.ietf.org/html/rfc3339.html) \[https://tools.ietf.org/html/rfc3339.html\] 。 如果你需要更多地控制日期/时间的格式，请为 `basicConfig` 提供 *datefmt* 参数，如下例所示:
```
import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')
```
这会显示如下内容：
```
12/12/2010 11:46:36 AM is when this event was logged.
```
*datefmt* 参数的格式与 [`time.strftime()`](../library/time.xhtml#time.strftime "time.strftime") 支持的格式相同。
### 后续步骤
基本教程到此结束。 它应该足以让你启动并运行日志记录。 日志包提供了更多功能，但为了充分利用它，你需要花更多的时间来阅读以下部分。 如果你准备好了，可以拿一些你最喜欢的饮料然后继续。
如果你的日志记录需求很简单，那么使用上面的示例将日志记录合并到你自己的脚本中，如果你遇到问题或者不理解某些内容，请在 comp.lang.python Usenet 组上发布一个问题（在 <https://groups.google.com/forum/#!forum/comp.lang.python> ） ，你应该在短时间内得到帮助。
还不够？ 你可以继续阅读接下来的几个部分，这些部分提供了比上面基本部分更高级或深入的教程。 之后，你可以看一下 [日志操作手册](logging-cookbook.xhtml#logging-cookbook) 。
## 进阶日志教程
日志库采用模块化方法，并提供几类组件：记录器、处理程序、过滤器和格式化程序。
- 记录器暴露了应用程序代码直接使用的接口。
- 处理程序将日志记录（由记录器创建）发送到适当的目标。
- 过滤器提供了更精细的附加功能，用于确定要输出的日志记录。
- 格式化程序指定最终输出中日志记录的样式。
日志事件信息在 [`LogRecord`](../library/logging.xhtml#logging.LogRecord "logging.LogRecord") 实例中的记录器、处理程序、过滤器和格式化程序之间传递。
通过调用 [`Logger`](../library/logging.xhtml#logging.Logger "logging.Logger") 类（以下称为 *loggers* ， 记录器）的实例来执行日志记录。 每个实例都有一个名称，它们在概念上以点（句点）作为分隔符排列在命名空间的层次结构中。 例如，名为 'scan' 的记录器是记录器 'scan.text' ，'scan.html' 和 'scan.pdf' 的父级。 记录器名称可以是你想要的任何名称，并指示记录消息源自的应用程序区域。
在命名记录器时使用的一个好习惯是在每个使用日志记录的模块中使用模块级记录器，命名如下:
```
logger = logging.getLogger(__name__)
```
这意味着记录器名称跟踪包或模块的层次结构，并且直观地从记录器名称显示记录事件的位置。
记录器层次结构的根称为根记录器。 这是函数 [`debug()`](../library/logging.xhtml#logging.debug "logging.debug") 、 [`info()`](../library/logging.xhtml#logging.info "logging.info") 、 [`warning()`](../library/logging.xhtml#logging.warning "logging.warning") 、 [`error()`](../library/logging.xhtml#logging.error "logging.error") 和 [`critical()`](../library/logging.xhtml#logging.critical "logging.critical") 使用的记录器，它们只调用根记录器的同名方法。 功能和方法具有相同的签名。 根记录器的名称在记录的输出中打印为 'root' 。
当然，可以将消息记录到不同的地方。 软件包中的支持包含，用于将日志消息写入文件、 HTTP GET/POST 位置、通过 SMTP 发送电子邮件、通用套接字、队列或特定于操作系统的日志记录机制（如 syslog 或 Windows NT 事件日志）。 目标由 *handler* 类提供。 如果你有任何内置处理程序类未满足的特殊要求，则可以创建自己的日志目标类。
默认情况下，没有为任何日志记录消息设置目标。 你可以使用 [`basicConfig()`](../library/logging.xhtml#logging.basicConfig "logging.basicConfig") 指定目标（例如控制台或文件），如教程示例中所示。 如果你调用函数 [`debug()`](../library/logging.xhtml#logging.debug "logging.debug") 、 [`info()`](../library/logging.xhtml#logging.info "logging.info") 、 [`warning()`](../library/logging.xhtml#logging.warning "logging.warning") 、 [`error()`](../library/logging.xhtml#logging.error "logging.error") 和 [`critical()`](../library/logging.xhtml#logging.critical "logging.critical") ，他们将检查是否有设置目的地；如果没有设置，它们将在委托给根记录器进行实际的消息输出之前设置目标为控制台（ `sys.stderr` ）和默认格式的显示消息。
由 [`basicConfig()`](../library/logging.xhtml#logging.basicConfig "logging.basicConfig") 设置的消息默认格式为：
```
severity:logger name:message
```
你可以通过使用 *format* 参数将格式字符串传递给 [`basicConfig()`](../library/logging.xhtml#logging.basicConfig "logging.basicConfig") 来更改此设置。有关如何构造格式字符串的所有选项，请参阅 [Formatter Objects](../library/logging.xhtml#formatter-objects) 。
### 记录流程
记录器和处理程序中的日志事件信息流程如下图所示。
### 记录器
[`Logger`](../library/logging.xhtml#logging.Logger "logging.Logger") 对象有三重任务。首先，它们向应用程序代码公开了几种方法，以便应用程序可以在运行时记录消息。其次，记录器对象根据严重性（默认过滤工具）或过滤器对象确定要处理的日志消息。第三，记录器对象将相关的日志消息传递给所有感兴趣的日志处理程序。
记录器对象上使用最广泛的方法分为两类：配置和消息发送。
这些是最常见的配置方法：
- [`Logger.setLevel()`](../library/logging.xhtml#logging.Logger.setLevel "logging.Logger.setLevel") 指定记录器将处理的最低严重性日志消息，其中 debug 是最低内置严重性级别， critical 是最高内置严重性级别。 例如，如果严重性级别为 INFO ，则记录器将仅处理 INFO 、 WARNING 、 ERROR 和 CRITICAL 消息，并将忽略 DEBUG 消息。
- [`Logger.addHandler()`](../library/logging.xhtml#logging.Logger.addHandler "logging.Logger.addHandler") 和 [`Logger.removeHandler()`](../library/logging.xhtml#logging.Logger.removeHandler "logging.Logger.removeHandler") 从记录器对象中添加和删除处理程序对象。处理程序在以下内容中有更详细的介绍 [处理程序](#handler-basic) 。
- [`Logger.addFilter()`](../library/logging.xhtml#logging.Logger.addFilter "logging.Logger.addFilter") 和 [`Logger.removeFilter()`](../library/logging.xhtml#logging.Logger.removeFilter "logging.Logger.removeFilter") 可以添加或移除记录器对象中的过滤器。 [Filter Objects](../library/logging.xhtml#filter) 包含更多的过滤器细节。
你不需要始终在你创建的每个记录器上调用这些方法。 请参阅本节的最后两段。
配置记录器对象后，以下方法将创建日志消息：
- [`Logger.debug()`](../library/logging.xhtml#logging.Logger.debug "logging.Logger.debug") 、 [`Logger.info()`](../library/logging.xhtml#logging.Logger.info "logging.Logger.info") 、 [`Logger.warning()`](../library/logging.xhtml#logging.Logger.warning "logging.Logger.warning") 、 [`Logger.error()`](../library/logging.xhtml#logging.Logger.error "logging.Logger.error") 和 [`Logger.critical()`](../library/logging.xhtml#logging.Logger.critical "logging.Logger.critical") 都创建日志记录，包含消息和与其各自方法名称对应的级别。该消息实际上是一个格式化字符串，它可能包含标题字符串替换语法 `%s` 、 `%d` 、 `%f` 等等。其余参数是与消息中的替换字段对应的对象列表。关于 `**kwargs` ，日志记录方法只关注 `exc_info` 的关键字，并用它来确定是否记录异常信息。
- [`Logger.exception()`](../library/logging.xhtml#logging.Logger.exception "logging.Logger.exception") 创建与 [`Logger.error()`](../library/logging.xhtml#logging.Logger.error "logging.Logger.error") 相似的日志信息。 不同之处是， [`Logger.exception()`](../library/logging.xhtml#logging.Logger.exception "logging.Logger.exception") 同时还记录当前的堆栈追踪。仅从异常处理程序调用此方法。
- [`Logger.log()`](../library/logging.xhtml#logging.Logger.log "logging.Logger.log") 将日志级别作为显式参数。对于记录消息而言，这比使用上面列出的日志级别方便方法更加冗长，但这是自定义日志级别的方法。
[`getLogger()`](../library/logging.xhtml#logging.getLogger "logging.getLogger") 返回对具有指定名称的记录器实例的引用（如果已提供），或者如果没有则返回 `root` 。名称是以句点分隔的层次结构。多次调用 [`getLogger()`](../library/logging.xhtml#logging.getLogger "logging.getLogger") 具有相同的名称将返回对同一记录器对象的引用。在分层列表中较低的记录器是列表中较高的记录器的子项。例如，给定一个名为 `foo` 的记录器，名称为 `foo.bar` 、 `foo.bar.baz` 和 `foo.bam` 的记录器都是 `foo` 子项。
记录器具有 *有效等级* 的概念。如果未在记录器上显式设置级别，则使用其父级别作为其有效级别。如果父级没有明确的级别设置，则检查 *其* 父级。依此类推，搜索所有上级元素，直到找到明确设置的级别。根记录器始终具有显式级别集（默认情况下为 `WARNING` ）。在决定是否处理事件时，记录器的有效级别用于确定事件是否传递给记录器的处理程序。
子记录器将消息传播到与其上级记录器关联的处理程序。因此，不必为应用程序使用的所有记录器定义和配置处理程序。为顶级记录器配置处理程序并根据需要创建子记录器就足够了。（但是，你可以通过将记录器的 *propagate* 属性设置 `False` 来关闭传播。）
### 处理程序
[`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 对象负责将适当的日志消息（基于日志消息的严重性）分派给处理程序的指定目标。 [`Logger`](../library/logging.xhtml#logging.Logger "logging.Logger") 对象可以使用 [`addHandler()`](../library/logging.xhtml#logging.Logger.addHandler "logging.Logger.addHandler") 方法向自己添加零个或多个处理程序对象。作为示例场景，应用程序可能希望将所有日志消息发送到日志文件，将错误或更高的所有日志消息发送到标准输出，以及将所有关键消息发送至一个邮件地址。 此方案需要三个单独的处理程序，其中每个处理程序负责将特定严重性的消息发送到特定位置。
标准库包含很多处理程序类型（参见 [有用的处理程序](#useful-handlers) ）；教程主要使用 [`StreamHandler`](../library/logging.handlers.xhtml#logging.StreamHandler "logging.StreamHandler") 和 [`FileHandler`](../library/logging.handlers.xhtml#logging.FileHandler "logging.FileHandler") 。
处理程序中很少有方法可供应用程序开发人员使用。与使用内置处理程序对象（即不创建自定义处理程序）的应用程序开发人员相关的唯一处理程序方法是以下配置方法：
- `setLevel()` 方法，就像在记录器对象中一样，指定将被分派到适当目标的最低严重性。为什么有两个 `setLevel()` 方法？记录器中设置的级别确定将传递给其处理程序的消息的严重性。每个处理程序中设置的级别确定处理程序将发送哪些消息。
- [`setFormatter()`](../library/logging.xhtml#logging.Handler.setFormatter "logging.Handler.setFormatter") 选择一个该处理程序使用的 Formatter 对象。
- [`addFilter()`](../library/logging.xhtml#logging.Handler.addFilter "logging.Handler.addFilter") 和 [`removeFilter()`](../library/logging.xhtml#logging.Handler.removeFilter "logging.Handler.removeFilter") 分别在处理程序上配置和取消配置过滤器对象。
应用程序代码不应直接实例化并使用 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 的实例。 相反， [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 类是一个基类，它定义了所有处理程序应该具有的接口，并建立了子类可以使用（或覆盖）的一些默认行为。
### 格式化程序
格式化程序对象配置日志消息的最终顺序、结构和内容。 与 [`logging.Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 类不同，应用程序代码可以实例化格式化程序类，但如果应用程序需要特殊行为，则可能会对格式化程序进行子类化。构造函数有三个可选参数 —— 消息格式字符串、日期格式字符串和样式指示符。
`logging.Formatter.``__init__`(*fmt=None*, *datefmt=None*, *style='%'*)如果没有消息格式字符串，则默认使用原始消息。如果没有日期格式字符串，则默认日期格式为：
```
%Y-%m-%d %H:%M:%S
```
最后加上毫秒数。 `style` 是 ％，'{ ' 或 '$' 之一。 如果未指定其中一个，则将使用 '％'。
如果 `style` 是 '％'，则消息格式字符串使用 `%(<dictionary key>)s` 样式字符串替换；可能的键值在 [LogRecord attributes](../library/logging.xhtml#logrecord-attributes) 中。 如果样式为 '{'，则假定消息格式字符串与 [`str.format()`](../library/stdtypes.xhtml#str.format "str.format") （使用关键字参数）兼容，而如果样式为 '$' ，则消息格式字符串应符合 [`string.Template.substitute()`](../library/string.xhtml#string.Template.substitute "string.Template.substitute") 。
在 3.2 版更改: 添加 `style` 形参。
以下消息格式字符串将以人类可读的格式记录时间、消息的严重性以及消息的内容，按此顺序:
```
'%(asctime)s - %(levelname)s - %(message)s'
```
格式化程序使用用户可配置的函数将记录的创建时间转换为元组。 默认情况下，使用 [`time.localtime()`](../library/time.xhtml#time.localtime "time.localtime") ；要为特定格式化程序实例更改此项，请将实例的 `converter` 属性设置为具有相同签名的函数 [`time.localtime()`](../library/time.xhtml#time.localtime "time.localtime") 或 [`time.gmtime()`](../library/time.xhtml#time.gmtime "time.gmtime") 。 要为所有格式化程序更改它，例如，如果你希望所有记录时间都以 GMT 显示，请在格式化程序类中设置 `converter` 属性（对于 GMT 显示，设置为 `time.gmtime` ）。
### 配置日志记录
开发者可以通过三种方式配置日志记录：
1. 使用调用上面列出的配置方法的 Python 代码显式创建记录器、处理程序和格式化程序。
2. 创建日志配置文件并使用 [`fileConfig()`](../library/logging.config.xhtml#logging.config.fileConfig "logging.config.fileConfig") 函数读取它。
3. 创建配置信息字典并将其传递给 [`dictConfig()`](../library/logging.config.xhtml#logging.config.dictConfig "logging.config.dictConfig") 函数。
有关最后两个选项的参考文档，请参阅 [Configuration functions](../library/logging.config.xhtml#logging-config-api) 。 以下示例使用 Python 代码配置一个非常简单的记录器/一个控制台处理程序和一个简单的格式化程序:
```
import logging
# create logger
logger = logging.getLogger('simple_example')
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')
```
从命令行运行此模块将生成以下输出：
```
$ python simple_logging_module.py
2005-03-19 15:10:26,618 - simple_example - DEBUG - debug message
2005-03-19 15:10:26,620 - simple_example - INFO - info message
2005-03-19 15:10:26,695 - simple_example - WARNING - warn message
2005-03-19 15:10:26,697 - simple_example - ERROR - error message
2005-03-19 15:10:26,773 - simple_example - CRITICAL - critical message
```
以下 Python 模块创建的记录器、处理程序和格式化程序几乎与上面列出的示例中的相同，唯一的区别是对象的名称:
```
import logging
import logging.config
logging.config.fileConfig('logging.conf')
# create logger
logger = logging.getLogger('simpleExample')
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')
```
这是 logging.conf 文件：
```
[loggers]
keys=root,simpleExample
[handlers]
keys=consoleHandler
[formatters]
keys=simpleFormatter
[logger_root]
level=DEBUG
handlers=consoleHandler
[logger_simpleExample]
level=DEBUG
handlers=consoleHandler
qualname=simpleExample
propagate=0
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=simpleFormatter
args=(sys.stdout,)
[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=
```
输出几乎与不基于配置文件的示例相同：
```
$ python simple_logging_config.py
2005-03-19 15:38:55,977 - simpleExample - DEBUG - debug message
2005-03-19 15:38:55,979 - simpleExample - INFO - info message
2005-03-19 15:38:56,054 - simpleExample - WARNING - warn message
2005-03-19 15:38:56,055 - simpleExample - ERROR - error message
2005-03-19 15:38:56,130 - simpleExample - CRITICAL - critical message
```
你可以看到配置文件方法比 Python 代码方法有一些优势，主要是配置和代码的分离以及非开发者轻松修改日志记录属性的能力。
警告
[`fileConfig()`](../library/logging.config.xhtml#logging.config.fileConfig "logging.config.fileConfig") 函数接受一个默认参数 `disable_existing_loggers` ，出于向后兼容的原因，默认为 `True` 。这可能是你想要的，也可能不是你想要的，因为除非在配置中明确命名它们（或一个上级节点中），否则它将导致在 [`fileConfig()`](../library/logging.config.xhtml#logging.config.fileConfig "logging.config.fileConfig") 调用之前存在的任何非 root 记录器被禁用。有关更多信息，请参阅参考文档，如果需要，请为此参数指定 `False` 。
传递给 [`dictConfig()`](../library/logging.config.xhtml#logging.config.dictConfig "logging.config.dictConfig") 的字典也可以用键 `disable_existing_loggers` 指定一个布尔值，如果没有在字典中明确指定，也默认被解释为 `True` 。这会导致上面描述的记录器禁用行为，这可能不是你想要的——在这种情况下，明确地为键提供 `False` 值。
请注意，配置文件中引用的类名称需要相对于日志记录模块，或者可以使用常规导入机制解析的绝对值。因此，你可以使用 [`WatchedFileHandler`](../library/logging.handlers.xhtml#logging.handlers.WatchedFileHandler "logging.handlers.WatchedFileHandler") （相对于日志记录模块）或 `mypackage.mymodule.MyHandler` （对于在 `mypackage` 包中定义的类和模块 `mymodule` ，其中 `mypackage` 在Python导入路径上可用）。
在 Python 3.2 中，引入了一种新的配置日志记录的方法，使用字典来保存配置信息。 这提供了上述基于配置文件方法的功能的超集，并且是新应用程序和部署的推荐配置方法。 因为 Python 字典用于保存配置信息，并且由于你可以使用不同的方式填充该字典，因此你有更多的配置选项。 例如，你可以使用 JSON 格式的配置文件，或者如果你有权访问 YAML 处理功能，则可以使用 YAML 格式的文件来填充配置字典。当然，你可以在 Python 代码中构造字典，通过套接字以 pickle 形式接收它，或者使用对你的应用程序合理的任何方法。
以下是与上述相同配置的示例，采用 YAML 格式，用于新的基于字典的方法：
```
version: 1
formatters:
simple:
format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
handlers:
console:
class: logging.StreamHandler
level: DEBUG
formatter: simple
stream: ext://sys.stdout
loggers:
simpleExample:
level: DEBUG
handlers: [console]
propagate: no
root:
level: DEBUG
handlers: [console]
```
有关使用字典进行日志记录的更多信息，请参阅 [Configuration functions](../library/logging.config.xhtml#logging-config-api) 。
### 如果没有提供配置会发生什么
如果未提供日志记录配置，则可能出现需要输出日志记录事件但无法找到输出事件的处理程序的情况。 在这些情况下，日志包的行为取决于 Python 版本。
对于3.2之前的Python版本，行为如下：
- 如果 *logging.raiseExceptions* 为 `False` （生产模式），则会以静默方式丢弃该事件。
- 如果 *logging.raiseExceptions* 为 `True` （开发模式），则会打印一条消息“无法找到记录器 X.Y.Z 的处理程序”。
在 Python 3.2 及更高版本中，行为如下：
- 事件使用“最后的处理程序”输出，存储在 `logging.lastResort` 中。 这个内部处理程序与任何记录器都没有关联，它的作用类似于 [`StreamHandler`](../library/logging.handlers.xhtml#logging.StreamHandler "logging.StreamHandler") ，它将事件描述消息写入 `sys.stderr` 的当前值（因此服从任何可能的重定向影响）。 没有对消息进行格式化——只打印裸事件描述消息。处理程序的级别设置为“警告”，因此将输出此级别和更高级别的所有事件。
要获得 3.2 之前的行为， `logging.lastResort` 可以设置为 `None` 。
### 配置库的日志记录
在开发使用日志记录的库时，你应该注意记录库如何使用日志记录——例如，使用的记录器的名称。还需要考虑其日志记录配置。如果应用程序不使用日志记录，并且库代码进行日志记录调用，那么（如上一节所述）严重性为“WARNING”及更高级别的事件将打印到 `sys.stderr` 。这被认为是最好的默认行为。
如果由于某种原因，你 *不* 希望在没有任何日志记录配置的情况下打印这些消息，则可以将无操作处理程序附加到库的顶级记录器。这样可以避免打印消息，因为将始终为库的事件找到处理程序：它不会产生任何输出。如果库用户配置应用程序使用的日志记录，可能是配置将添加一些处理程序，如果级别已适当配置，则在库代码中进行的日志记录调用将正常地将输出发送给这些处理程序。
日志包中包含一个不做任何事情的处理程序： [`NullHandler`](../library/logging.handlers.xhtml#logging.NullHandler "logging.NullHandler") （自 Python 3.1 起）。可以将此处理程序的实例添加到库使用的日志记录命名空间的顶级记录器中（ *如果* 你希望在没有日志记录配置的情况下阻止库的记录事件输出到 `sys.stderr` ）。如果库 *foo* 的所有日志记录都是使用名称匹配 'foo.x' ， 'foo.x.y' 等的记录器完成的，那么代码:
```
import logging
logging.getLogger('foo').addHandler(logging.NullHandler())
```
应该有预计的效果。如果一个组织生成了许多库，则指定的记录器名称可以是 “orgname.foo” 而不仅仅是 “foo” 。
注解
强烈建议你 *不要将* [`NullHandler`](../library/logging.handlers.xhtml#logging.NullHandler "logging.NullHandler") *以外的任何处理程序添加到库的记录器中* 。这是因为处理程序的配置是使用你的库的应用程序开发人员的权利。应用程序开发人员了解他们的目标受众以及哪些处理程序最适合他们的应用程序：如果你在“底层”添加处理程序，则可能会干扰他们执行单元测试和提供符合其要求的日志的能力。
## 日志级别
日志记录级别的数值在下表中给出。如果你想要定义自己的级别，并且需要它们具有相对于预定义级别的特定值，那么这些内容可能是你感兴趣的。如果你定义具有相同数值的级别，它将覆盖预定义的值; 预定义的名称丢失。
级别
数值
`CRITICAL`
50
`ERROR`
40
`WARNING`
30
`INFO`
20
`DEBUG`
10
`NOTSET`
0
级别也可以与记录器相关联，由开发人员设置或通过加载已保存的日志记录配置。在记录器上调用日志记录方法时，记录器会将其自己的级别与与方法调用关联的级别进行比较。如果记录器的级别高于方法调用的级别，则实际上不会生成任何记录消息。这是控制日志记录输出详细程度的基本机制。
记录消息被编码为 [`LogRecord`](../library/logging.xhtml#logging.LogRecord "logging.LogRecord") 类的实例。当记录器决定实际记录事件时，从记录消息创建 [`LogRecord`](../library/logging.xhtml#logging.LogRecord "logging.LogRecord") 实例。
记录消息通过使用 *handlers* 进行调度机制，它们是 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 类的子类的实例。处理程序负责确保记录的消息（以 [`LogRecord`](../library/logging.xhtml#logging.LogRecord "logging.LogRecord") 的形式）最终位于特定位置（或一组位置），这对该消息的目标受众（例如最终用户、 支持服务台员工、系统管理员、开发人员）。传递处理程序用于特定目标的 [`LogRecord`](../library/logging.xhtml#logging.LogRecord "logging.LogRecord") 实例。 每个记录器可以有零个、一个或多个与之关联的处理程序（通过 [`Logger`](../library/logging.xhtml#logging.Logger "logging.Logger") 的 [`addHandler()`](../library/logging.xhtml#logging.Logger.addHandler "logging.Logger.addHandler") 方法）。除了与记录器直接关联的任何处理程序之外，还调用与记录器的 *所有祖先相关联的所有处理程序来分派消息（除非记录器的 \*propagate* 标志设置为false值，这将停止传递到上级处理程序）。
就像记录器一样，处理程序可以具有与它们相关联的级别。处理程序的级别作为过滤器，其方式与记录器级别相同。如果处理程序决定调度一个事件，则使用 `emit()` 方法将消息发送到其目标。大多数用户定义的 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 子类都需要重载 `emit()` 。
### 自定义级别
定义你自己的级别是可能的，但不一定是必要的，因为现有级别是根据实践经验选择的。但是，如果你确信需要自定义级别，那么在执行此操作时应特别小心，如果你正在开发库，则 *定义自定义级别可能是一个非常糟糕的主意* 。 这是因为如果多个库作者都定义了他们自己的自定义级别，那么使用开发人员很难控制和解释这些多个库的日志记录输出，因为给定的数值可能意味着不同的东西 对于不同的库。
## 有用的处理程序
作为 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 基类的补充，提供了很多有用的子类：
1. [`StreamHandler`](../library/logging.handlers.xhtml#logging.StreamHandler "logging.StreamHandler") 实例发送消息到流（类似文件对象）。
2. [`FileHandler`](../library/logging.handlers.xhtml#logging.FileHandler "logging.FileHandler") 实例将消息发送到硬盘文件。
3. [`BaseRotatingHandler`](../library/logging.handlers.xhtml#logging.handlers.BaseRotatingHandler "logging.handlers.BaseRotatingHandler") 是轮换日志文件的处理程序的基类。它并不应该直接实例化。而应该使用 [`RotatingFileHandler`](../library/logging.handlers.xhtml#logging.handlers.RotatingFileHandler "logging.handlers.RotatingFileHandler") 或 [`TimedRotatingFileHandler`](../library/logging.handlers.xhtml#logging.handlers.TimedRotatingFileHandler "logging.handlers.TimedRotatingFileHandler") 代替它。
4. [`RotatingFileHandler`](../library/logging.handlers.xhtml#logging.handlers.RotatingFileHandler "logging.handlers.RotatingFileHandler") 实例将消息发送到硬盘文件，支持最大日志文件大小和日志文件轮换。
5. [`TimedRotatingFileHandler`](../library/logging.handlers.xhtml#logging.handlers.TimedRotatingFileHandler "logging.handlers.TimedRotatingFileHandler") 实例将消息发送到硬盘文件，以特定的时间间隔轮换日志文件。
6. [`SocketHandler`](../library/logging.handlers.xhtml#logging.handlers.SocketHandler "logging.handlers.SocketHandler") 实例将消息发送到 TCP/IP 套接字。从 3.4 开始，也支持 Unix 域套接字。
7. [`DatagramHandler`](../library/logging.handlers.xhtml#logging.handlers.DatagramHandler "logging.handlers.DatagramHandler") 实例将消息发送到 UDP 套接字。从 3.4 开始，也支持 Unix 域套接字。
8. [`SMTPHandler`](../library/logging.handlers.xhtml#logging.handlers.SMTPHandler "logging.handlers.SMTPHandler") 实例将消息发送到指定的电子邮件地址。
9. [`SysLogHandler`](../library/logging.handlers.xhtml#logging.handlers.SysLogHandler "logging.handlers.SysLogHandler") 实例将消息发送到 Unix syslog 守护程序，可能在远程计算机上。
10. [`NTEventLogHandler`](../library/logging.handlers.xhtml#logging.handlers.NTEventLogHandler "logging.handlers.NTEventLogHandler") 实例将消息发送到 Windows NT/2000/XP 事件日志。
11. [`MemoryHandler`](../library/logging.handlers.xhtml#logging.handlers.MemoryHandler "logging.handlers.MemoryHandler") 实例将消息发送到内存中的缓冲区，只要满足特定条件，缓冲区就会刷新。
12. [`HTTPHandler`](../library/logging.handlers.xhtml#logging.handlers.HTTPHandler "logging.handlers.HTTPHandler") 实例使用 `GET` 或 `POST` 方法将消息发送到 HTTP 服务器。
13. [`WatchedFileHandler`](../library/logging.handlers.xhtml#logging.handlers.WatchedFileHandler "logging.handlers.WatchedFileHandler") 实例会监视他们要写入日志的文件。如果文件发生更改，则会关闭该文件并使用文件名重新打开。此处理程序仅在类 Unix 系统上有用； Windows 不支持依赖的基础机制。
14. [`QueueHandler`](../library/logging.handlers.xhtml#logging.handlers.QueueHandler "logging.handlers.QueueHandler") 实例将消息发送到队列，例如在 [`queue`](../library/queue.xhtml#module-queue "queue: A synchronized queue class.") 或 [`multiprocessing`](../library/multiprocessing.xhtml#module-multiprocessing "multiprocessing: Process-based parallelism.") 模块中实现的队列。
15. [`NullHandler`](../library/logging.handlers.xhtml#logging.NullHandler "logging.NullHandler") 实例对错误消息不执行任何操作。它们由想要使用日志记录的库开发人员使用，但是想要避免如果库用户没有配置日志记录，则显示 "无法找到记录器XXX的消息处理器" 消息的情况。有关更多信息，请参阅 [配置库的日志记录](#library-config) 。
3\.1 新版功能: [`NullHandler`](../library/logging.handlers.xhtml#logging.NullHandler "logging.NullHandler") 类。
3\.2 新版功能: [`QueueHandler`](../library/logging.handlers.xhtml#logging.handlers.QueueHandler "logging.handlers.QueueHandler") 类。
The [`NullHandler`](../library/logging.handlers.xhtml#logging.NullHandler "logging.NullHandler") 、 [`StreamHandler`](../library/logging.handlers.xhtml#logging.StreamHandler "logging.StreamHandler") 和 [`FileHandler`](../library/logging.handlers.xhtml#logging.FileHandler "logging.FileHandler") 类在核心日志包中定义。其他处理程序定义在 [`logging.handlers`](../library/logging.handlers.xhtml#module-logging.handlers "logging.handlers: Handlers for the logging module.") 中。（还有另一个子模块 [`logging.config`](../library/logging.config.xhtml#module-logging.config "logging.config: Configuration of the logging module.") ，用于配置功能）
记录的消息被格式化为通过 [`Formatter`](../library/logging.xhtml#logging.Formatter "logging.Formatter") 类的实例进行呈现。 它们使用适合与 ％ 运算符一起使用的格式字符串和字典进行初始化。
对于批量格式化多个消息，可以使用 `BufferingFormatter` 的实例。除了格式字符串（应用于批处理中的每个消息）之外，还提供了标题和尾部格式字符串。
当基于记录器级别和处理程序级别的过滤不够时，可以将 [`Filter`](../library/logging.xhtml#logging.Filter "logging.Filter") 的实例添加到 [`Logger`](../library/logging.xhtml#logging.Logger "logging.Logger") 和 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 实例（通过它们的 [`addFilter()`](../library/logging.xhtml#logging.Handler.addFilter "logging.Handler.addFilter") 方法）。在决定进一步处理消息之前，记录器和处理程序都会查询其所有过滤器以获得许可。如果任何过滤器返回 false 值，则不会进一步处理该消息。
基本 [`Filter`](../library/logging.xhtml#logging.Filter "logging.Filter") 的功能允许按特定的记录器名称进行过滤。如果使用此功能，则允许通过过滤器发送到指定记录器及其子项的消息，并丢弃所有消息。
## 记录日志中引发的异常
日志包设计为忽略记录日志生产时发生的异常。这样，处理日志记录事件时发生的错误（例如日志记录错误配置、网络或其他类似错误）不会导致使用日志记录的应用程序过早终止。
[`SystemExit`](../library/exceptions.xhtml#SystemExit "SystemExit") 和 [`KeyboardInterrupt`](../library/exceptions.xhtml#KeyboardInterrupt "KeyboardInterrupt") 异常永远不会被忽略。 在 [`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 子类的 `emit()` 方法中发生的其他异常被传递给它的 `handleError()` 方法。
[`Handler`](../library/logging.xhtml#logging.Handler "logging.Handler") 中默认实现的 `handleError()` 检查是否设置了模块级变量 `raiseExceptions` 。如果有设置，则会将跟踪打印到 [`sys.stderr`](../library/sys.xhtml#sys.stderr "sys.stderr") 。如果未设置，则忽略异常。
注解
`raiseExceptions` 默认值是 `True`。 这是因为在开发期间，你通常希望收到任何发生异常的通知。建议你将 `raiseExceptions` 设置为 `False` 以供生产环境使用。
## 使用任意对象作为消息
在前面的部分和示例中，都假设记录事件时传递的消息是字符串。 但是，这不是唯一的可能性。你可以将任意对象作为消息传递，并且当日志记录系统需要将其转换为字符串表示时，将调用其 `__ str__()` 方法。实际上，如果你愿意，你可以完全避免计算字符串表示。例如， [`SocketHandler`](../library/logging.handlers.xhtml#logging.handlers.SocketHandler "logging.handlers.SocketHandler") 通过 pickle 并网络发送来发出事件。
## 优化
消息参数的格式化将被推迟，直到无法避免。但是，计算传递给日志记录方法的参数也可能很消耗资源，如果记录器只是丢弃你的事件，你可能希望避免这样做。要决定做什么，可以调用 [`isEnabledFor()`](../library/logging.xhtml#logging.Logger.isEnabledFor "logging.Logger.isEnabledFor") 方法，该方法接受一个 level 参数，如果记录器为该级别的调用创建了该事件，则返回 true 。 你可以写这样的代码:
```
if logger.isEnabledFor(logging.DEBUG):
logger.debug('Message with %s, %s', expensive_func1(),
expensive_func2())
```
因此，如果记录器的阈值设置在“DEBUG”以上，则永远不会调用 `expensive_func1()` 和 `expensive_func2()` 。
注解
在某些情况下， [`isEnabledFor()`](../library/logging.xhtml#logging.Logger.isEnabledFor "logging.Logger.isEnabledFor") 本身可能比你想要的更消耗资源（例如，对于深度嵌套的记录器，其中显式级别仅在记录器层次结构中设置为高）。在这种情况下（或者如果你想避免在紧密循环中调用方法），你可以在本地或实例变量中将调用的结果缓存到 [`isEnabledFor()`](../library/logging.xhtml#logging.Logger.isEnabledFor "logging.Logger.isEnabledFor") ，并使用它而不是调用每次方法。只在日志记录配置在应用程序运行时动态更改（这不常见）时需重新计算这样的缓存值。
对于需要对收集的日志信息进行更精确控制的特定应用程序，还可以进行其他优化。 以下是你可以执行的操作列表，以避免在你不需要的日志记录期间进行处理：
你不想收集的内容
如何避免收集它
有关调用来源的信息
将 `logging._srcfile` 设置为 `None` 。这避免了调用 [`sys._getframe()`](../library/sys.xhtml#sys._getframe "sys._getframe") ，如果 PyPy 支持 Python 3.x ,这可能有助于加速 PyPy （无法加速使用 [`sys._getframe()`](../library/sys.xhtml#sys._getframe "sys._getframe") 的代码）等环境中的代码.
线程信息
将 `logging.logThreads` 置为 `0` 。
进程信息
将 `logging.logProcesses` 置为 `0` 。
另请注意，核心日志记录模块仅包含基本处理程序。如果你不导入 [`logging.handlers`](../library/logging.handlers.xhtml#module-logging.handlers "logging.handlers: Handlers for the logging module.") 和 [`logging.config`](../library/logging.config.xhtml#module-logging.config "logging.config: Configuration of the logging module.") ，它们将不会占用任何内存。
参见
模块 [`logging`](../library/logging.xhtml#module-logging "logging: Flexible event logging system for applications.")日志记录模块的 API 参考。
模块 [`logging.config`](../library/logging.config.xhtml#module-logging.config "logging.config: Configuration of the logging module.")日志记录模块的配置 API 。
模块 [`logging.handlers`](../library/logging.handlers.xhtml#module-logging.handlers "logging.handlers: Handlers for the logging module.")日志记录模块附带的有用处理程序。
[A logging cookbook](logging-cookbook.xhtml#logging-cookbook)
### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](logging-cookbook.xhtml "日志操作手册") |
- [上一页](functional.xhtml "函数式编程指引") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 常用指引](index.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