logging — Python 的日志记录工具

源代码: Lib/logging/__init__.py

重要

此页面包含 API 参考信息。有关教程信息和更高级主题的讨论，请参阅

• 基本教程

• 高级教程

• 日志记录 Cookbook

---

此模块定义了为应用程序和库实现灵活的事件日志记录系统的函数和类。

由标准库模块提供日志记录 API 的主要好处是，所有 Python 模块都可以参与日志记录，因此您的应用程序日志可以包含您自己的消息以及来自第三方模块的消息。

这是一个惯用用法的简单示例

# myapp.py
import logging
import mylib
logger = logging.getLogger(__name__)

def main():
    logging.basicConfig(filename='myapp.log', level=logging.INFO)
    logger.info('Started')
    mylib.do_something()
    logger.info('Finished')

if __name__ == '__main__':
    main()

# mylib.py
import logging
logger = logging.getLogger(__name__)

def do_something():
    logger.info('Doing something')

如果您运行 *myapp.py*，您应该在 *myapp.log* 中看到以下内容

INFO:__main__:Started
INFO:mylib:Doing something
INFO:__main__:Finished

这种惯用用法的关键特性是，大部分代码只是使用 getLogger(__name__) 创建模块级记录器，并使用该记录器执行任何所需的日志记录。这既简洁，又允许下游代码在需要时进行细粒度的控制。发送到模块级记录器的日志消息会被转发到更高级别模块中的记录器的处理程序，一直到最高级别的记录器（称为根记录器）；这种方法称为分层日志记录。

要使日志记录有用，需要对其进行配置：为每个记录器设置级别和目标，可能根据命令行参数或应用程序配置更改特定模块的日志记录方式。在大多数情况下，像上面的示例一样，只需要配置根记录器，因为所有较低级别的模块级记录器最终都会将其消息转发到其处理程序。basicConfig() 提供了一种快速配置根记录器的方法，该方法可以处理许多用例。

该模块提供了很多功能和灵活性。如果您不熟悉日志记录，最好的方法是查看教程（**请参阅上面的和右侧的链接**）。

模块定义的基本类及其属性和方法在以下各节中列出。

• 记录器公开应用程序代码直接使用的接口。

• 处理程序将日志记录（由记录器创建）发送到适当的目标。

• 过滤器提供更细粒度的工具，用于确定要输出哪些日志记录。

• 格式化程序指定最终输出中日志记录的布局。

Logger 对象

记录器具有以下属性和方法。请注意，不应直接实例化记录器，而应始终通过模块级函数 logging.getLogger(name) 实例化。使用相同的名称多次调用 getLogger() 将始终返回对同一 Logger 对象的引用。

name 可能是句点分隔的分层值，例如 foo.bar.baz（尽管例如，它也可能只是普通的 foo）。在分层列表中更靠下的记录器是列表中更高位置的记录器的子记录器。例如，给定一个名为 foo 的记录器，名称为 foo.bar、foo.bar.baz 和 foo.bam 的记录器都是 foo 的后代。此外，所有记录器都是根记录器的后代。记录器名称层次结构类似于 Python 包层次结构，如果您使用建议的结构 logging.getLogger(__name__) 按模块组织记录器，则与 Python 包层次结构相同。那是因为在模块中，__name__ 是该模块在 Python 包命名空间中的名称。

class logging.Logger

name

这是记录器的名称，并且是传递给 getLogger() 以获取记录器的值。

注意

此属性应视为只读。

level

此记录器的阈值，由 setLevel() 方法设置。

注意

请勿直接设置此属性 - 始终使用 setLevel()，它会对传递给它的级别进行检查。

parent

此记录器的父记录器。它可能会根据以后实例化的在命名空间层次结构中更高的记录器而更改。

注意

此值应视为只读。

propagate

如果此属性的计算结果为 true，则除了附加到此记录器的任何处理程序之外，记录到此记录器的事件将传递给更高级别（祖先）记录器的处理程序。消息直接传递到祖先记录器的处理程序 - 不考虑相关祖先记录器的级别或过滤器。

如果此属性的计算结果为 false，则不会将日志记录消息传递到祖先记录器的处理程序。

用一个示例来说明：如果名为 A.B.C 的记录器的 propagate 属性的计算结果为 true，则通过方法调用（例如 logging.getLogger('A.B.C').error(...)）记录到 A.B.C 的任何事件将 [在通过该记录器的级别和过滤器设置后] 依次传递给附加到名为 A.B、A 和根记录器的任何处理程序，在首先传递给附加到 A.B.C 的任何处理程序之后。如果链 A.B.C、A.B、A 中的任何记录器的 propagate 属性设置为 false，则该记录器是最后一个向其处理程序提供要处理的事件的记录器，并且传播在该点停止。

构造函数将此属性设置为 True。

注意

如果将处理器附加到记录器和其一个或多个祖先记录器，则可能会多次发出相同的记录。一般来说，您不需要将处理器附加到多个记录器 - 如果您只是将其附加到记录器层次结构中最高的适当记录器，那么它将看到所有后代记录器记录的所有事件，前提是它们的 propagate 设置保持为 True。一个常见的场景是将处理器仅附加到根记录器，并让传播处理其余的事情。

handlers

直接附加到此记录器实例的处理器列表。

注意

此属性应被视为只读属性；它通常通过 addHandler() 和 removeHandler() 方法进行更改，这些方法使用锁来确保线程安全操作。

disabled

此属性禁用对任何事件的处理。它在初始化程序中设置为 False，并且仅由日志配置代码更改。

注意

此属性应视为只读。

setLevel(level)

设置此记录器的阈值为 level。严重性低于 level 的日志消息将被忽略；严重性等于或高于 level 的日志消息将由服务此记录器的任何处理器发出，除非处理器的级别已设置为高于 level 的严重性级别。

创建记录器时，级别设置为 NOTSET（这会导致当记录器是根记录器时处理所有消息，或者当记录器是非根记录器时委托给父记录器）。请注意，根记录器创建时的级别为 WARNING。

术语“委托给父级”意味着如果记录器的级别为 NOTSET，则会遍历其祖先记录器的链，直到找到级别不是 NOTSET 的祖先，或者到达根为止。

如果找到级别不是 NOTSET 的祖先，则该祖先的级别被视为祖先搜索开始的记录器的有效级别，并用于确定如何处理日志事件。

如果到达根，并且其级别为 NOTSET，则将处理所有消息。否则，根的级别将用作有效级别。

有关级别列表，请参见 日志级别。

在 3.2 版本中更改：level 参数现在接受级别的字符串表示形式，例如 ‘INFO’，作为整数常量（如 INFO）的替代方法。但是，请注意，级别在内部存储为整数，并且诸如 getEffectiveLevel() 和 isEnabledFor() 之类的方法将返回/期望传递整数。

isEnabledFor(level)

指示此记录器是否会处理严重性为 level 的消息。此方法首先检查 logging.disable(level) 设置的模块级级别，然后检查由 getEffectiveLevel() 确定的记录器的有效级别。

getEffectiveLevel()

指示此记录器的有效级别。如果已使用 setLevel() 设置了 NOTSET 以外的值，则会返回该值。否则，层次结构会向根遍历，直到找到 NOTSET 以外的值，并返回该值。返回的值是一个整数，通常是 logging.DEBUG、logging.INFO 等。

getChild(suffix)

返回一个记录器，该记录器是此记录器的后代，由后缀确定。因此，logging.getLogger('abc').getChild('def.ghi') 将返回与 logging.getLogger('abc.def.ghi') 返回的记录器相同的记录器。这是一个方便的方法，当父记录器使用例如 __name__ 而不是字面字符串命名时很有用。

在 3.2 版本中添加。

getChildren()

返回一个记录器集合，这些记录器是此记录器的直接子记录器。因此，例如，logging.getLogger().getChildren() 可能会返回一个包含名为 foo 和 bar 的记录器的集合，但名为 foo.bar 的记录器将不会包含在该集合中。同样，logging.getLogger('foo').getChildren() 可能会返回一个包含名为 foo.bar 的记录器的集合，但它不会包含一个名为 foo.bar.baz 的记录器。

在 3.12 版本中添加。

debug(msg, *args, **kwargs)

在此记录器上使用级别 DEBUG 记录消息。msg 是消息格式字符串，args 是使用字符串格式化运算符合并到 msg 中的参数。（请注意，这意味着您可以在格式字符串中使用关键字，以及一个字典参数。）当没有提供 args 时，不会对 msg 执行 % 格式化操作。

在 kwargs 中检查四个关键字参数：exc_info、stack_info、stacklevel 和 extra。

如果 exc_info 的计算结果不为假，则会导致异常信息被添加到日志消息中。如果提供了异常元组（格式由 sys.exc_info() 返回）或异常实例，则会使用它；否则，将调用 sys.exc_info() 来获取异常信息。

第二个可选关键字参数是 stack_info，它默认为 False。如果为 true，则会将堆栈信息添加到日志消息中，包括实际的日志调用。请注意，这与通过指定 exc_info 显示的堆栈信息不同：前者是从堆栈底部到当前线程中日志调用的堆栈帧，而后者是关于堆栈帧的信息，这些堆栈帧是在异常发生后在搜索异常处理程序时展开的。

您可以独立于 exc_info 指定 stack_info，例如，仅显示您如何在代码中达到某个点，即使没有引发异常。堆栈帧在标题行之后打印，该标题行说

Stack (most recent call last):

这模仿了显示异常帧时使用的 Traceback (most recent call last):。

第三个可选关键字参数是 stacklevel，它默认为 1。如果大于 1，则在计算为日志事件创建的 LogRecord 中设置的行号和函数名时，将跳过相应数量的堆栈帧。这可以在日志助手中使用，以便记录的函数名、文件名和行号不是助手函数/方法的信息，而是其调用者的信息。此参数的名称与 warnings 模块中的等效参数相呼应。

第四个关键字参数是 extra，它可用于传递一个字典，该字典用于填充为日志事件创建的 __dict__ LogRecord，其中包含用户定义的属性。 这些自定义属性可以按需使用。 例如，可以将它们合并到记录的消息中。例如

FORMAT = '%(asctime)s %(clientip)-15s %(user)-8s %(message)s'
logging.basicConfig(format=FORMAT)
d = {'clientip': '192.168.0.1', 'user': 'fbloggs'}
logger = logging.getLogger('tcpserver')
logger.warning('Protocol problem: %s', 'connection reset', extra=d)

会打印如下内容：

2006-02-08 22:20:02,165 192.168.0.1 fbloggs  Protocol problem: connection reset

传递给 extra 的字典中的键不应与日志系统使用的键冲突。（有关日志系统使用哪些键的更多信息，请参阅 LogRecord 属性 部分。）

如果您选择在记录的消息中使用这些属性，则需要小心。例如，在上面的示例中， Formatter 已设置为格式字符串，该格式字符串期望 LogRecord 的属性字典中存在 “clientip” 和 “user”。 如果缺少这些属性，则不会记录消息，因为会发生字符串格式化异常。因此，在这种情况下，您始终需要传递带有这些键的 extra 字典。

虽然这可能很烦人，但此功能旨在用于特殊情况，例如在多线程服务器中，相同的代码在许多上下文中执行，并且出现的有趣情况取决于此上下文（例如，在上面的示例中，远程客户端 IP 地址和经过身份验证的用户名）。 在这种情况下，很可能会将特殊的 Formatter 与特定的 Handler 一起使用。

如果没有处理程序附加到此记录器（或其任何祖先，考虑到相关的 Logger.propagate 属性），则消息将发送到 lastResort 上设置的处理程序。

在 3.2 版本中变更: 添加了 stack_info 参数。

在 3.5 版本中变更: exc_info 参数现在可以接受异常实例。

在 3.8 版本中变更: 添加了 stacklevel 参数。

info(msg, *args, **kwargs)

在此记录器上记录级别为 INFO 的消息。 参数的解释与 debug() 相同。

warning(msg, *args, **kwargs)

在此记录器上记录级别为 WARNING 的消息。 参数的解释与 debug() 相同。

注意

有一个已过时的方法 warn，其功能与 warning 完全相同。 由于 warn 已弃用，请不要使用它，而应使用 warning。

error(msg, *args, **kwargs)

在此记录器上记录级别为 ERROR 的消息。 参数的解释与 debug() 相同。

critical(msg, *args, **kwargs)

在此记录器上记录级别为 CRITICAL 的消息。 参数的解释与 debug() 相同。

log(level, msg, *args, **kwargs)

在此记录器上记录整数级别 level 的消息。 其他参数的解释与 debug() 相同。

exception(msg, *args, **kwargs)

在此记录器上记录级别为 ERROR 的消息。 参数的解释与 debug() 相同。 异常信息会添加到日志消息中。 此方法应仅从异常处理程序中调用。

addFilter(filter)

将指定的过滤器 filter 添加到此记录器。

removeFilter(filter)

从此记录器中删除指定的过滤器 filter。

filter(record)

将此记录器的过滤器应用于记录，如果记录要被处理，则返回 True。 依次咨询过滤器，直到其中一个过滤器返回假值。 如果它们都没有返回假值，则将处理记录（传递给处理程序）。 如果其中一个返回假值，则不会进一步处理记录。

addHandler(hdlr)

将指定的处理程序 hdlr 添加到此记录器。

removeHandler(hdlr)

从此记录器中删除指定的处理程序 hdlr。

findCaller(stack_info=False, stacklevel=1)

查找调用者的源文件名和行号。返回文件名、行号、函数名和堆栈信息作为 4 个元素的元组。堆栈信息以 None 形式返回，除非 stack_info 为 True。

stacklevel 参数是从调用 debug() 和其他 API 的代码传递的。如果大于 1，则在确定要返回的值之前，多余的值用于跳过堆栈帧。当从辅助/包装器代码调用日志 API 时，这通常很有用，以便事件日志中的信息不是指辅助/包装器代码，而是指调用它的代码。

handle(record)

通过将其传递给与此记录器及其祖先关联的所有处理程序（直到找到 propagate 的假值）来处理记录。此方法用于从套接字接收的未腌制记录，以及本地创建的记录。使用 filter() 应用记录器级过滤。

makeRecord(name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)

这是一个工厂方法，可以在子类中重写，以创建专门的 LogRecord 实例。

hasHandlers()

检查此记录器是否配置了任何处理程序。这是通过查找此记录器及其在记录器层次结构中的父级中的处理程序来完成的。如果找到处理程序，则返回 True，否则返回 False。当找到一个将“propagate”属性设置为 false 的记录器时，该方法将停止向上搜索层次结构 - 这将是最后一个检查是否存在处理程序的记录器。

在 3.2 版本中添加。

3.7 版本更改: 记录器现在可以进行 pickle 和 unpickle 操作。

日志级别

日志级别的数值在下表中给出。如果您想定义自己的级别，并且需要它们相对于预定义级别具有特定的值，那么这些级别主要会引起您的兴趣。如果您定义一个具有相同数值的级别，它会覆盖预定义的值；预定义的名称将丢失。

级别	数值	含义/何时使用
logging.NOTSET	0	当在记录器上设置时，表示将参考祖先记录器来确定有效级别。如果仍然解析为 NOTSET，则会记录所有事件。当在处理程序上设置时，将处理所有事件。
logging.DEBUG	10	详细信息，通常仅对尝试诊断问题的开发人员感兴趣。
logging.INFO	20	确认一切都按预期工作。
logging.WARNING	30	表明发生了意外情况，或者在不久的将来可能发生问题（例如“磁盘空间不足”）。该软件仍在按预期工作。
logging.ERROR	40	由于更严重的问题，该软件无法执行某些功能。
logging.CRITICAL	50	一个严重的错误，表明程序本身可能无法继续运行。

处理程序对象

处理程序具有以下属性和方法。请注意，Handler 永远不会直接实例化；此类充当更有用的子类的基础。但是，子类中的 __init__() 方法需要调用 Handler.__init__()。

class logging.Handler

__init__(level=NOTSET)

通过设置其级别、将过滤器列表设置为空列表并创建一个锁（使用 createLock()）来初始化 Handler 实例，以序列化对 I/O 机制的访问。

createLock()

初始化一个线程锁，该线程锁可用于序列化对可能不是线程安全的底层 I/O 功能的访问。

acquire()

获取使用 createLock() 创建的线程锁。

release()

释放使用 acquire() 获取的线程锁。

setLevel(level)

将此处理程序的阈值设置为 level。将忽略严重性低于 level 的日志消息。创建处理程序时，级别设置为 NOTSET（这将导致处理所有消息）。

有关级别列表，请参见 日志级别。

3.2 版本更改: level 参数现在接受级别的字符串表示形式，例如 'INFO'，作为整数常量（如 INFO）的替代方法。

setFormatter(fmt)

将此处理程序的 Formatter 设置为 fmt。

addFilter(filter)

将指定的过滤器 filter 添加到此处理程序。

removeFilter(filter)

从此处理程序中删除指定的过滤器 filter。

filter(record)

将此处理程序的过滤器应用于记录，如果记录将被处理，则返回 True。将依次咨询过滤器，直到其中一个返回 false 值。如果没有一个返回 false 值，则将发出该记录。如果一个返回 false 值，则处理程序将不发出该记录。

flush()

确保所有日志输出都已刷新。此版本不执行任何操作，旨在由子类实现。

close()

整理处理程序使用的任何资源。此版本不输出任何内容，但会从 shutdown() 被调用时关闭的处理程序内部列表中删除该处理程序。子类应确保从重写的 close() 方法中调用此方法。

handle(record)

根据可能已添加到处理程序的过滤器有条件地发出指定的日志记录。使用 I/O 线程锁的获取/释放来包装记录的实际发出。

handleError(record)

当在 emit() 调用期间遇到异常时，应从处理程序中调用此方法。如果模块级属性 raiseExceptions 为 False，则会静默忽略异常。这对于日志记录系统来说是大多数情况下需要的 - 大多数用户不会关心日志记录系统中的错误，他们更关心应用程序错误。但是，如果您愿意，可以将此替换为自定义处理程序。指定的记录是发生异常时正在处理的记录。（raiseExceptions 的默认值为 True，因为这在开发过程中更有用）。

format(record)

为记录进行格式化 - 如果设置了格式化程序，则使用它。否则，使用模块的默认格式化程序。

emit(record)

执行实际记录指定日志记录所需的任何操作。此版本旨在由子类实现，因此会引发 NotImplementedError。

警告

此方法在获取处理程序级锁后调用，该锁在此方法返回后释放。重写此方法时，请注意在调用任何调用可能执行锁定的日志记录 API 的其他部分时应小心，因为这可能会导致死锁。具体来说

• 日志配置 API 会获取模块级锁，然后在配置这些处理程序时获取各个处理程序级别的锁。

• 许多日志 API 会锁定模块级别的锁。如果从该方法调用此类 API，则可能会导致死锁，因为如果在另一个线程上进行配置调用，该线程将尝试在处理程序级别的锁之前获取模块级别的锁，而此线程尝试在处理程序级别的锁之后获取模块级别的锁（因为在此方法中，已获取处理程序级别的锁）。

有关作为标准包含的处理程序列表，请参阅 logging.handlers。

格式化器对象

class logging.Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)

负责将 LogRecord 转换为供人或外部系统解释的输出字符串。

参数：

• fmt (str) – 给定样式中用于整个日志输出的格式字符串。可能的映射键来自 LogRecord 对象的 LogRecord 属性。如果未指定，则使用 '%(message)s'，它只是记录的消息。

• datefmt (str) – 给定样式中用于日志输出的日期/时间部分的格式字符串。如果未指定，则使用 formatTime() 中描述的默认值。

• style (str) – 可以是 '%'、'{' 或 '$' 中的一个，并确定格式字符串如何与其数据合并：使用 printf 样式字符串格式化 (%)、str.format() ({) 或 string.Template ($) 之一。这仅适用于 fmt 和 datefmt（例如，'%(message)s' 与 '{message}'），而不适用于传递给日志方法的实际日志消息。但是，还有 其他方式 可以对日志消息使用 { 和 $ 格式化。

• validate (bool) – 如果 True（默认值），则不正确或不匹配的 fmt 和 style 将引发 ValueError；例如，logging.Formatter('%(asctime)s - %(message)s', style='{')。

• defaults (dict[str, Any]) – 包含要在自定义字段中使用的默认值的字典。例如，logging.Formatter('%(ip)s %(message)s', defaults={"ip": None})

在 3.2 版本中更改: 添加了 style 参数。

在 3.8 版本中更改: 添加了 validate 参数。

在 3.10 版本中更改: 添加了 defaults 参数。

format(record)

记录的属性字典用作字符串格式化操作的操作数。返回结果字符串。在格式化字典之前，会执行几个准备步骤。记录的 message 属性是使用 msg % args 计算的。如果格式化字符串包含 '(asctime)'，则调用 formatTime() 来格式化事件时间。如果存在异常信息，则使用 formatException() 进行格式化，并将其附加到消息中。请注意，格式化的异常信息缓存在属性 exc_text 中。这很有用，因为异常信息可以被 pickle 序列化并通过网络发送，但如果你有多个 Formatter 子类，它们自定义异常信息的格式化，你应该小心。在这种情况下，你必须在格式化程序完成格式化后清除缓存值（通过将 exc_text 属性设置为 None），以便下一个处理事件的格式化程序不使用缓存值，而是重新计算它。

如果堆栈信息可用，则在使用 formatStack() 必要时转换后，将其附加到异常信息之后。

formatTime(record, datefmt=None)

应该由想要使用格式化时间的格式化程序从 format() 中调用此方法。可以在格式化程序中重写此方法以满足任何特定要求，但基本行为如下：如果指定了 datefmt（一个字符串），则将其与 time.strftime() 一起使用来格式化记录的创建时间。否则，使用格式 '%Y-%m-%d %H:%M:%S,uuu'，其中 uuu 部分是毫秒值，其他字母与 time.strftime() 文档一致。此格式的示例时间为 2003-01-23 00:29:50,411。返回结果字符串。

此函数使用用户可配置的函数将创建时间转换为元组。默认情况下，使用 time.localtime()；要为特定的格式化程序实例更改此设置，请将 converter 属性设置为与 time.localtime() 或 time.gmtime() 具有相同签名的函数。要为所有格式化程序更改它，例如，如果你希望所有日志时间都以 GMT 显示，请在 Formatter 类中设置 converter 属性。

在 3.3 版本中更改: 以前，默认格式在此示例中被硬编码：2010-09-06 22:38:15,292，其中逗号前的部分由 strptime 格式字符串 ('%Y-%m-%d %H:%M:%S') 处理，而逗号后的部分是毫秒值。由于 strptime 没有用于毫秒的格式占位符，因此使用另一个格式字符串 '%s,%03d' 附加毫秒值 — 并且这两个格式字符串都已硬编码到此方法中。通过更改，这些字符串被定义为类级属性，可以在需要时在实例级别重写。属性的名称是 default_time_format（用于 strptime 格式字符串）和 default_msec_format（用于附加毫秒值）。

在 3.9 版本中更改: default_msec_format 可以为 None。

formatException(exc_info)

将指定的异常信息（sys.exc_info() 返回的标准异常元组）格式化为字符串。此默认实现仅使用 traceback.print_exception()。返回结果字符串。

formatStack(stack_info)

将指定的堆栈信息（由 traceback.print_stack() 返回的字符串，但删除了最后一个换行符）格式化为字符串。此默认实现仅返回输入值。

class logging.BufferingFormatter(linefmt=None)

一个基础格式化器类，当您想格式化多个记录时，适合用作子类。您可以传递一个 Formatter 实例，您想用它来格式化每一行（对应于单个记录）。如果未指定，则使用默认格式化器（仅输出事件消息）作为行格式化器。

formatHeader(records)

返回一个 records 列表的头部。基本实现只返回空字符串。如果您想要特定的行为，例如显示记录计数、标题或分隔线，您将需要覆盖此方法。

formatFooter(records)

返回一个 records 列表的尾部。基本实现只返回空字符串。如果您想要特定的行为，例如显示记录计数或分隔线，您将需要覆盖此方法。

format(records)

返回 records 列表的格式化文本。基本实现如果没有任何记录，则返回空字符串；否则，它返回头部、每个使用行格式化器格式化的记录以及尾部的连接。

过滤器对象

Filters 可以被 Handlers 和 Loggers 使用，以实现比级别提供的更复杂的过滤。基本过滤器类只允许记录器层次结构中低于特定点的事件。例如，使用 'A.B' 初始化的过滤器将允许记录器 'A.B'、'A.B.C'、'A.B.C.D'、'A.B.D' 等记录的事件，但不允许 'A.BB'、'B.A.B' 等。如果使用空字符串初始化，则所有事件都会被传递。

class logging.Filter(name='')

返回 Filter 类的实例。如果指定了 name，它将命名一个记录器，连同其子记录器，它们的事件将允许通过过滤器。如果 name 是空字符串，则允许所有事件。

filter(record)

是否要记录指定的记录？返回 false 表示否，返回 true 表示是。过滤器可以就地修改日志记录，或者返回一个完全不同的记录实例，它将在事件的任何未来处理中替换原始日志记录。

请注意，附加到处理程序的过滤器会在处理程序发出事件之前进行检查，而附加到记录器的过滤器会在每次记录事件时（使用 debug(), info() 等）进行检查，然后才将事件发送给处理程序。这意味着，除非过滤器也已应用于这些后代记录器，否则由后代记录器生成的事件不会被记录器的过滤器设置过滤。

您实际上不需要子类化 Filter：您可以传递任何具有相同语义的 filter 方法的实例。

在 3.2 版本中更改: 您不需要创建专门的 Filter 类，或使用其他具有 filter 方法的类：您可以将函数（或其他可调用对象）用作过滤器。过滤逻辑将检查过滤器对象是否具有 filter 属性：如果它有，则假定它是一个 Filter，并调用其 filter() 方法。否则，它被假定为一个可调用对象，并使用记录作为单个参数进行调用。返回的值应符合 filter() 返回的值。

在 3.12 版本中更改: 您现在可以从过滤器返回一个 LogRecord 实例来替换日志记录，而不是就地修改它。这允许附加到 Handler 的过滤器在发出日志记录之前修改它，而不会对其他处理程序产生副作用。

虽然过滤器主要用于根据比级别更复杂的标准过滤记录，但它们会看到附加到它们的处理程序或记录器处理的每个记录：如果您想执行诸如计算特定记录器或处理程序处理了多少条记录，或在正在处理的 LogRecord 中添加、更改或删除属性等操作，这会很有用。显然，更改 LogRecord 需要谨慎进行，但它确实允许将上下文信息注入到日志中（请参阅 使用过滤器来传递上下文信息）。

LogRecord 对象

LogRecord 实例由 Logger 在每次记录某些内容时自动创建，并且可以通过 makeLogRecord() 手动创建（例如，从通过网络接收的 pickle 事件中创建）。

class logging.LogRecord(name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None)

包含与正在记录的事件相关的所有信息。

主要信息在 msg 和 args 中传递，它们使用 msg % args 组合以创建记录的 message 属性。

参数：

• name (str) – 用于记录此 LogRecord 表示的事件的记录器的名称。请注意，LogRecord 中的记录器名称将始终具有此值，即使它可能由附加到不同（祖先）记录器的处理程序发出。

• level (int) – 日志事件的 数值级别（例如 DEBUG 为 10，INFO 为 20 等）。请注意，这会转换为 LogRecord 的两个属性：levelno 表示数值，levelname 表示相应的级别名称。

• pathname (str) – 进行日志记录调用的源文件的完整字符串路径。

• lineno (int) – 进行日志记录调用的源文件中的行号。

• msg (Any) – 事件描述消息，它可以是带有变量数据占位符的 %-格式字符串，或者是一个任意对象（请参阅 使用任意对象作为消息）。

• args (tuple | dict[str, Any]) – 合并到 msg 参数中以获得事件描述的变量数据。

• exc_info (tuple[type[BaseException], BaseException, types.TracebackType] | None) – 一个包含当前异常信息的元组，由 sys.exc_info() 返回，如果当前没有异常信息则为 None。

• func (str | None) – 发起日志调用的函数或方法的名称。

• sinfo (str | None) – 一个文本字符串，表示当前线程中从栈底到日志调用处的栈信息。

getMessage()

返回此 LogRecord 实例的消息，该消息是将用户提供的任何参数与消息合并后得到的。如果用户提供给日志调用的消息参数不是字符串，则会调用 str() 将其转换为字符串。这允许使用用户定义的类作为消息，其 __str__ 方法可以返回要使用的实际格式字符串。

在 3.2 版本中更改: 通过提供用于创建记录的工厂，LogRecord 的创建变得更加可配置。可以使用 getLogRecordFactory() 和 setLogRecordFactory() 设置工厂（请参阅此处的工厂签名）。

此功能可用于在创建时将您自己的值注入到 LogRecord 中。您可以使用以下模式

old_factory = logging.getLogRecordFactory()

def record_factory(*args, **kwargs):
    record = old_factory(*args, **kwargs)
    record.custom_attribute = 0xdecafbad
    return record

logging.setLogRecordFactory(record_factory)

使用此模式，可以链接多个工厂，只要它们不覆盖彼此的属性或无意中覆盖上面列出的标准属性，就不会有意外情况。

LogRecord 属性

LogRecord 有许多属性，其中大多数属性是从构造函数的参数派生的。（请注意，LogRecord 构造函数参数和 LogRecord 属性之间的名称并不总是完全对应。）这些属性可用于将记录中的数据合并到格式字符串中。下表按字母顺序列出了属性名称、它们的含义以及 % 风格格式字符串中对应的占位符。

如果您使用 {} 格式化 (str.format())，则可以使用 {attrname} 作为格式字符串中的占位符。如果您使用 $ 格式化 (string.Template)，则使用 ${attrname} 的形式。当然，在这两种情况下，都要将 attrname 替换为您要使用的实际属性名称。

在使用 {} 格式化的情况下，您可以通过将格式标志放在属性名称之后，并用冒号将其隔开来指定格式标志。例如：占位符 {msecs:03.0f} 会将毫秒值 4 格式化为 004。有关可用选项的完整详细信息，请参阅 str.format() 文档。

属性名称	格式	描述
args	您不需要自己格式化此项。	合并到 msg 中以生成 message 的参数元组，或者是一个字典，其值用于合并（当只有一个参数并且它是一个字典时）。
asctime	%(asctime)s	创建 LogRecord 时的人类可读时间。默认情况下，此格式为“2003-07-08 16:49:45,896”（逗号后的数字是时间的毫秒部分）。
created	%(created)f	创建 LogRecord 的时间（由 time.time_ns() / 1e9 返回）。
exc_info	您不需要自己格式化此项。	异常元组（类似于 sys.exc_info）或，如果没有发生异常，则为 None。
filename	%(filename)s	pathname 的文件名部分。
funcName	%(funcName)s	包含日志调用的函数的名称。
levelname	%(levelname)s	消息的文本日志级别（'DEBUG'、'INFO'、'WARNING'、'ERROR'、'CRITICAL'）。
levelno	%(levelno)s	消息的数字日志级别（DEBUG、INFO、WARNING、ERROR、CRITICAL）。
lineno	%(lineno)d	发出日志调用的源行号（如果可用）。
message	%(message)s	记录的消息，计算为 msg % args。这是在调用 Formatter.format() 时设置的。
module	%(module)s	filename 的模块（名称部分）。
msecs	%(msecs)d	创建 LogRecord 的时间的毫秒部分。
msg	您不需要自己格式化此项。	在原始日志调用中传递的格式字符串。与 args 合并以生成 message，或者是一个任意对象（请参阅 使用任意对象作为消息）。
name	%(name)s	用于记录调用的记录器的名称。
pathname	%(pathname)s	发出日志调用的源文件的完整路径名（如果可用）。
process	%(process)d	进程 ID（如果可用）。
processName	%(processName)s	进程名称（如果可用）。
relativeCreated	%(relativeCreated)d	创建 LogRecord 的时间（以毫秒为单位），相对于加载日志模块的时间。
stack_info	您不需要自己格式化此项。	从当前线程的栈底到（包括）导致创建此记录的日志调用的栈帧的堆栈帧信息（如果可用）。
thread	%(thread)d	线程 ID（如果可用）。
threadName	%(threadName)s	线程名称（如果可用）。
taskName	%(taskName)s	asyncio.Task 名称（如果可用）。

在 3.1 版本中更改: 添加了 processName。

在 3.12 版本中更改: 添加了 taskName。

LoggerAdapter 对象

LoggerAdapter 实例用于方便地将上下文信息传递到日志调用中。有关用法示例，请参阅关于向日志输出添加上下文信息的部分。

class logging.LoggerAdapter(logger, extra, merge_extra=False)

返回一个 LoggerAdapter 的实例，该实例使用底层的 Logger 实例、一个类似字典的对象 (extra) 和一个布尔值 (merge_extra) 进行初始化，该布尔值指示是否应将各个日志调用的 extra 参数与 LoggerAdapter 的 extra 合并。默认行为是忽略各个日志调用的 extra 参数，仅使用 LoggerAdapter 实例的 extra。

process(msg, kwargs)

修改传递给日志调用的消息和/或关键字参数，以便插入上下文信息。此实现采用作为 extra 传递给构造函数的对象，并使用键 ‘extra’ 将其添加到 kwargs 中。返回值是一个 (msg, kwargs) 元组，其中包含传入参数的（可能修改过的）版本。

manager

委托给 logger 上的底层 manager。

_log

委托给 logger 上的底层 _log() 方法。

除了上述内容外，LoggerAdapter 还支持 Logger 的以下方法：debug()、info()、warning()、error()、exception()、critical()、log()、isEnabledFor()、getEffectiveLevel()、setLevel() 和 hasHandlers()。 这些方法具有与 Logger 中的对应方法相同的签名，因此您可以互换使用这两种类型的实例。

在 3.2 版本中更改: isEnabledFor()、getEffectiveLevel()、setLevel() 和 hasHandlers() 方法已添加到 LoggerAdapter。这些方法委托给底层记录器。

在 3.6 版本中更改: 添加了属性 manager 和方法 _log()，它们委托给底层记录器并允许嵌套适配器。

在 3.13 版本中更改: 添加了 merge_extra 参数。

线程安全

日志模块旨在线程安全，无需其客户端进行任何特殊操作。它通过使用线程锁来实现这一点；有一个锁用于序列化对模块共享数据的访问，并且每个处理程序还创建一个锁用于序列化对其底层 I/O 的访问。

如果您使用 signal 模块实现异步信号处理程序，您可能无法从这些处理程序中使用日志记录。这是因为 threading 模块中的锁实现并非总是可重入的，因此无法从这些信号处理程序中调用。

模块级函数

除了上面描述的类之外，还有许多模块级函数。

logging.getLogger(name=None)

返回具有指定名称的记录器，如果 name 为 None，则返回层次结构的根记录器。如果指定了名称，则该名称通常是点分隔的分层名称，如 'a'、'a.b' 或 'a.b.c.d'。 这些名称的选择完全取决于使用日志记录的开发人员，但建议使用 __name__，除非您有特定的理由不这样做，如 记录器对象 中所述。

对具有给定名称的此函数的所有调用都返回相同的记录器实例。这意味着记录器实例无需在应用程序的不同部分之间传递。

logging.getLoggerClass()

返回标准 Logger 类，或传递给 setLoggerClass() 的最后一个类。 可以从新的类定义中调用此函数，以确保安装自定义 Logger 类不会撤消其他代码已应用的自定义项。例如

class MyLogger(logging.getLoggerClass()):
    # ... override behaviour here

logging.getLogRecordFactory()

返回一个可调用对象，该对象用于创建 LogRecord。

在 3.2 版本中添加: 已提供此函数以及 setLogRecordFactory()，以使开发人员可以更好地控制如何构造表示日志事件的 LogRecord。

有关如何调用工厂的更多信息，请参见 setLogRecordFactory()。

logging.debug(msg, *args, **kwargs)

这是一个方便的函数，它在根记录器上调用 Logger.debug()。 参数的处理方式与该方法中所述的完全相同。

唯一的区别是，如果根记录器没有处理程序，则在根记录器上调用 debug 之前，会调用 basicConfig()。

对于非常短的脚本或 logging 功能的快速演示，debug 和其他模块级函数可能很方便。但是，大多数程序会希望仔细而明确地控制日志记录配置，因此应该首选创建模块级记录器并在其上调用 Logger.debug() （或其他特定级别的方法），如此文档开头所述。

logging.info(msg, *args, **kwargs)

在根记录器上记录一条级别为 INFO 的消息。参数和行为与其他方面与 debug() 相同。

logging.warning(msg, *args, **kwargs)

在根记录器上记录一条级别为 WARNING 的消息。参数和行为与其他方面与 debug() 相同。

注意

有一个已过时的函数 warn，其功能与 warning 完全相同。由于 warn 已被弃用，请不要使用它，而应使用 warning。

logging.error(msg, *args, **kwargs)

在根记录器上记录一条级别为 ERROR 的消息。参数和行为与其他方面与 debug() 相同。

logging.critical(msg, *args, **kwargs)

在根记录器上记录一条级别为 CRITICAL 的消息。参数和行为与其他方面与 debug() 相同。

logging.exception(msg, *args, **kwargs)

在根记录器上记录一条级别为 ERROR 的消息。参数和行为与其他方面与 debug() 相同。异常信息将添加到日志消息中。此函数应仅从异常处理程序中调用。

logging.log(level, msg, *args, **kwargs)

在根记录器上记录一条级别为 level 的消息。参数和行为与其他方面与 debug() 相同。

logging.disable(level=CRITICAL)

为所有记录器提供一个覆盖级别 *level*，该级别优先于记录器自身的级别。当需要暂时降低整个应用程序的日志输出时，此函数非常有用。它的作用是禁用所有严重性为 *level* 及以下的日志调用，因此，如果您使用 INFO 值调用它，则所有 INFO 和 DEBUG 事件都将被丢弃，而严重性为 WARNING 及以上的事件将根据记录器的有效级别进行处理。如果调用 logging.disable(logging.NOTSET)，它会有效地删除此覆盖级别，以便日志输出再次取决于各个记录器的有效级别。

请注意，如果您定义了任何高于 CRITICAL 的自定义日志级别（不建议这样做），则您将无法依赖 *level* 参数的默认值，而必须显式提供合适的值。

在 3.7 版本中更改：*level* 参数的默认值更改为级别 CRITICAL。有关此更改的更多信息，请参阅 bpo-28524。

logging.addLevelName(level, levelName)

将级别 *level* 与文本 *levelName* 关联到内部字典中，该字典用于将数字级别映射到文本表示形式，例如，当 Formatter 格式化消息时。此函数还可用于定义自己的级别。唯一的约束是，所有使用的级别都必须使用此函数注册，级别应该是正整数，并且它们的严重性应按递增的顺序增加。

注意

如果您正在考虑定义自己的级别，请参阅关于 自定义级别 的部分。

logging.getLevelNamesMapping()

返回从级别名称到其相应日志级别的映射。例如，字符串“CRITICAL”映射到 CRITICAL。返回的映射是从每次调用此函数时从内部映射中复制的。

在 3.11 版本中添加。

logging.getLevelName(level)

返回日志级别 *level* 的文本或数字表示形式。

如果 *level* 是预定义级别 CRITICAL、ERROR、WARNING、INFO 或 DEBUG 之一，则您将获得相应的字符串。如果您已使用 addLevelName() 将级别与名称关联，则将返回您与 *level* 关联的名称。如果传入与已定义级别之一对应的数值，则返回相应的字符串表示形式。

*level* 参数还接受级别的字符串表示形式，例如“INFO”。在这种情况下，此函数返回级别的相应数值。

如果未传入匹配的数值或字符串值，则返回字符串“Level %s” % level。

注意

级别在内部是整数（因为它们需要在日志记录逻辑中进行比较）。此函数用于在整数级别和通过 %(levelname)s 格式说明符（请参阅 LogRecord 属性）在格式化的日志输出中显示的级别名称之间进行转换，反之亦然。

在 3.4 版本中更改：在早于 3.4 的 Python 版本中，此函数也可以传递文本级别，并且会返回级别的相应数值。这种未记录的行为被认为是错误的，并在 Python 3.4 中删除，但由于要保持向后兼容性，在 3.4.2 中恢复。

logging.getHandlerByName(name)

返回具有指定 *name* 的处理程序，如果不存在具有该名称的处理程序，则返回 None。

在 3.12 版本中添加。

logging.getHandlerNames()

返回所有已知处理器名称的不可变集合。

在 3.12 版本中添加。

logging.makeLogRecord(attrdict)

创建并返回一个新的 LogRecord 实例，其属性由 attrdict 定义。此函数对于获取通过套接字发送的 pickled LogRecord 属性字典，并在接收端将其重新构建为 LogRecord 实例非常有用。

logging.basicConfig(**kwargs)

通过创建一个带有默认 Formatter 的 StreamHandler 并将其添加到根记录器，来为日志系统进行基本配置。如果根记录器未定义任何处理器，则函数 debug()、 info()、 warning()、 error() 和 critical() 将会自动调用 basicConfig()。

如果根记录器已经配置了处理器，则此函数不执行任何操作，除非关键字参数 force 设置为 True。

注意

此函数应在启动其他线程之前从主线程调用。在 Python 2.7.1 和 3.2 之前的版本中，如果此函数从多个线程调用，则可能会（在极少数情况下）将处理器多次添加到根记录器，从而导致意外的结果，例如日志中出现重复消息。

支持以下关键字参数。

格式	描述
filename	指定创建一个使用指定文件名而不是 StreamHandler 的 FileHandler。
filemode	如果指定了 filename，则以该 模式 打开文件。默认为 'a'。
format	对处理器使用指定的格式字符串。默认为以冒号分隔的属性 levelname、name 和 message。
datefmt	使用 time.strftime() 接受的指定日期/时间格式。
style	如果指定了 format，则对格式字符串使用此样式。对于 printf-style、str.format() 或 string.Template，分别为 '%'、 '{' 或 '$' 之一。默认为 '%'。
level	将根记录器级别设置为指定的级别。
stream	使用指定的流初始化 StreamHandler。请注意，此参数与 filename 不兼容 - 如果两者都存在，则会引发 ValueError。
handlers	如果指定，这应该是一个已创建的处理器可迭代对象，以添加到根记录器。任何尚未设置格式化程序的处理器都将分配在此函数中创建的默认格式化程序。请注意，此参数与 filename 或 stream 不兼容 - 如果两者都存在，则会引发 ValueError。
force	如果将此关键字参数指定为 true，则会删除并关闭附加到根记录器的任何现有处理器，然后再执行其他参数指定的配置。
encoding	如果此关键字参数与 filename 一起指定，则在创建 FileHandler 时使用其值，因此在打开输出文件时使用。
errors	如果此关键字参数与 filename 一起指定，则在创建 FileHandler 时使用其值，因此在打开输出文件时使用。如果未指定，则使用值“backslashreplace”。请注意，如果指定了 None，它将按原样传递给 open()，这意味着它的处理方式与传递“errors”相同。

在 3.2 版本中变更: 添加了 style 参数。

在 3.3 版本中变更: 添加了 handlers 参数。添加了其他检查，以捕获指定不兼容参数的情况（例如，handlers 与 stream 或 filename 一起，或者 stream 与 filename 一起）。

在 3.8 版本中变更: 添加了 force 参数。

在 3.9 版本中变更: 添加了 encoding 和 errors 参数。

logging.shutdown()

通过刷新并关闭所有处理器来通知日志系统执行有序关闭。这应该在应用程序退出时调用，并且在此调用后不应再使用日志系统。

导入日志模块时，它会将此函数注册为退出处理器（请参阅 atexit），因此通常无需手动执行此操作。

logging.setLoggerClass(klass)

告诉日志系统在实例化记录器时使用类 klass。该类应定义 __init__()，以便仅需要一个 name 参数，并且 __init__() 应调用 Logger.__init__()。此函数通常在需要使用自定义记录器行为的应用程序实例化任何记录器之前调用。在此调用之后，与任何其他时间一样，请勿使用子类直接实例化记录器：继续使用 logging.getLogger() API 获取记录器。

logging.setLogRecordFactory(factory)

设置一个用于创建 LogRecord 的可调用对象。

参数：

factory – 用于实例化日志记录的工厂可调用对象。

在 3.2 版本中新增: 已提供此函数以及 getLogRecordFactory()，以允许开发人员更好地控制如何构造表示日志记录事件的 LogRecord。

工厂具有以下签名

factory(name, level, fn, lno, msg, args, exc_info, func=None, sinfo=None, **kwargs)

name:

记录器名称。

level:

日志记录级别（数字）。

fn:

进行日志记录调用的文件的完整路径名。

lno:

进行日志记录调用的文件中的行号。

msg:

日志记录消息。

args:

日志记录消息的参数。

exc_info:

异常元组或 None。

func:

调用日志记录调用的函数或方法的名称。

sinfo:

堆栈回溯，例如由 traceback.print_stack() 提供，显示调用层次结构。

kwargs:

其他关键字参数。

模块级属性

logging.lastResort

通过此属性可以使用“最后的处理程序”。这是一个写入 sys.stderr 的 StreamHandler，级别为 WARNING，用于在没有任何日志配置的情况下处理日志事件。最终结果是将消息打印到 sys.stderr。这取代了之前表示“找不到记录器 XYZ 的处理程序”的错误消息。如果出于某种原因需要之前的行为，可以将 lastResort 设置为 None。

在 3.2 版本中添加。

logging.raiseExceptions

用于查看在处理期间是否应传播异常。

默认值：True。

如果 raiseExceptions 为 False，则异常将被静默忽略。这对于日志记录系统来说大多是需要的——大多数用户不会关心日志记录系统中的错误，他们更关心应用程序错误。

与 warnings 模块集成

captureWarnings() 函数可用于将 logging 与 warnings 模块集成。

logging.captureWarnings(capture)

此函数用于打开和关闭日志记录捕获警告的功能。

如果 capture 为 True，则 warnings 模块发出的警告将重定向到日志记录系统。具体来说，将使用 warnings.formatwarning() 格式化警告，并将生成的字符串记录到名为 'py.warnings' 的记录器中，严重级别为 WARNING。

如果 capture 为 False，则将停止将警告重定向到日志记录系统，并且警告将重定向到其原始目标（即在调用 captureWarnings(True) 之前生效的目标）。

另请参阅

模块 logging.config

日志模块的配置 API。

模块 logging.handlers

日志模块中包含的有用处理程序。

PEP 282 - 日志系统

该提案描述了将此功能包含在 Python 标准库中。

原始 Python 日志包

这是 logging 包的原始来源。此站点提供的软件包版本适用于 Python 1.5.2、2.1.x 和 2.2.x，这些版本在标准库中不包含 logging 包。