【Python学习笔记】Python logging模块的学习

当谈到日志记录时，logging库是Python中最常用的工具之一。它提供了许多功能和选项，使开发人员能够灵活地记录和管理应用程序的日志信息。

引入logging作为Python应用程序的日志记录库是至关重要的。它可以帮助开发人员维护和调试代码，跟踪应用状态，并为故障排查、性能分析和统计提供有用的信息。logging库的灵活性、多级别支持和可扩展性使其成为Python开发人员首选的日志记录工具。

基础介绍

logging是Python标准库中的模块，它提供了实现灵活的日志记录功能的工具和类。作为标准库的一部分，logging模块可以直接使用，而无需额外的安装和配置。

该模块提供了一套丰富的工具，例如Logger类、Handler类、Formatter类和Filter类，用于管理和控制日志记录的不同方面。开发人员可以使用Logger类来创建和配置日志记录器，使用Handler类来指定日志消息的输出位置和方式，使用Formatter类来定义日志消息的格式，以及使用Filter类来筛选特定的日志消息。

作用与功能

• 记录和跟踪：logging库提供了一种可靠的方式来记录应用程序运行时的事件、状态和错误信息。通过定义不同级别的日志消息，开发人员可以精确地记录应用程序的行为，以便在需要时进行跟踪和分析。

• 调试和故障排查：通过在代码中插入适当的日志语句，可以帮助开发人员调试和定位应用程序中的问题和错误。通过查看日志消息，可以了解代码执行的路径、变量值和异常情况，从而更好地理解问题所在。

• 监控和统计：logging库可以用于监控应用程序的行为和性能。通过记录关键指标和操作，开发人员可以在生产环境中实时监测应用程序的运行情况，并进行统计分析，以便做出相应的优化和调整。

• 灵活性和配置：logging库允许开发人员根据具体需求自定义日志记录的格式、级别和处理方式。可以将日志消息输出到不同位置，如控制台、文件或远程服务器，也可以定义过滤器和处理器来筛选和处理特定的日志消息。

• 多模块和多进程支持：logging库在多模块和多进程的应用程序开发中表现良好。可以在不同的模块中使用相同的日志配置，并且可以通过适当的配置来处理多个进程中的并发日志记录。

基本用法

引入模块

• 在Python代码中引入logging模块非常简单。只需在代码的开头部分使用import语句即可引入logging模块，如下所示：

  import logging
  

  一旦引入了logging模块，就可以在代码中使用其中定义的类和函数，以实现灵活的日志记录功能。比如，可以创建Logger对象来记录日志消息，使用不同级别的函数（如debug()、info()、warning()、error()和critical()）来写入相应级别的日志信息。

  引入logging模块后，可以根据具体需求来配置日志记录的方式、输出位置、格式和级别，以满足应用程序的日志记录需求。

创建并配置记录器的基本步骤

1. 创建Logger对象：首先，需要创建Logger对象，用于记录日志消息。可以通过logging.getLogger()方法来创建Logger对象，也可以直接使用logging模块中预定义的根记录器。

import logging

logger = logging.getLogger('my_logger')

2. 配置日志记录器：接下来，可以对Logger对象进行配置，以指定日志记录的输出位置、格式、级别等。可以配置多个处理器（Handler）和过滤器（Filter）来实现不同的日志记录需求。

file_handler = logging.FileHandler('app.log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

logger.setLevel(logging.DEBUG)

在上述示例中，为Logger对象添加了一个FileHandler处理器，用于将日志消息输出到名为app.log的文件中。还为处理器指定了日志消息的格式，以及为Logger对象设置了记录级别为DEBUG，这意味着所有DEBUG级别及以上的日志消息都会被记录。

3. 记录日志消息：创建并配置日志记录器后，即可通过调用Logger对象的不同级别的日志记录函数来记录日志消息。例如，可以使用debug()、info()、warning()、error()和critical()等函数来记录不同级别的日志消息。

logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

通过以上步骤，我们可以创建并配置Logger对象，以实现灵活的日志记录功能，并记录各种级别的日志消息。

创建和配置日志记录器的基本步骤包括创建Logger对象，配置处理器和过滤器，设置记录级别，以及记录日志消息。这些步骤可以根据应用程序的具体需求和要求来进行灵活配置，以实现清晰和有效的日志记录功能。

代码演示

当创建并配置了日志记录器后，可以在代码中添加日志记录语句来记录各种级别的日志消息。以下是一个简单的完整示例，演示了如何在代码中添加日志记录语句：

import logging

# 创建Logger对象
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建文件处理器并设置日志级别
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.DEBUG)

# 创建日志消息格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)

# 将处理器添加到日志记录器
logger.addHandler(file_handler)

# 添加日志记录语句
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

在上述示例中，我们首先创建了一个名为"my_logger"的Logger对象，并设置其记录级别为DEBUG。然后，我们创建了一个FileHandler处理器，指定了处理器的记录级别为DEBUG，并设置了日志消息的格式。接着，我们将FileHandler处理器添加到Logger对象中。最后，我们使用Logger对象的不同级别的日志记录函数来添加日志记录语句，记录各种级别的日志消息。

当运行以上代码时，日志消息将会被记录到名为app.log的日志文件中，且每条消息会包括时间戳、记录器名称、日志级别和具体消息内容。

通过在代码中添加日志记录语句，可以实时监控应用程序的行为，并在需要时对其进行调试和故障排除。同时，也可以根据记录的日志消息来分析应用程序的运行情况和问题发生原因。

日志级别

Python的logging模块提供了五个不同的日志级别，用于记录不同严重程度的日志消息。下面逐个介绍这五个级别：

• DEBUG（调试）级别：最低级别的日志级别。
  • 典型用例：用于详细跟踪和调试应用程序的运行过程，包括变量值、函数调用、代码流程等详细信息。
  • 何时使用：在开发和调试阶段，当需要获取最详细的运行信息以进行故障排除和代码调试时使用。不建议在生产环境中启用此级别的日志记录，因为会带来额外的性能开销和日志文件的增大。

import logging

logging.debug("This is a debug message")

• INFO（信息）级别：信息级别的日志级别。用于记录应用程序的重要运行信息，对于查看系统状态和信息非常有用。例如，记录应用程序启动信息、关键参数值等。
  • 典型用例：用于记录应用程序的相关信息，如应用程序的启动、重要参数值、关键操作的执行等。
  • 何时使用：用于显示应用程序的当前状态和重要信息，能够帮助查看系统状态和运行状况。在生产环境中常用于显示关键性的运行日志记录。

import logging

logging.info("This is an info message")

• WARNING（警告）级别：警告级别的日志级别。
  • 典型用例：用于记录可能会导致问题或异常情况的非致命性警告信息，但不会导致应用程序停止运行。
  • 何时使用：警告级别用于记录一些不寻常但不会中断应用程序正常运行的情况，例如无法找到期望的配置、请求的资源未找到等。

import logging

logging.warning("This is a warning message")

• ERROR（错误）级别：错误级别的日志级别。
  • 典型用例：用于记录一些发生错误但不会导致应用程序停止运行的情况。例如，数据库连接失败、API调用出错等。
  • 何时使用：当应用程序发生可恢复的错误或异常时，可以使用错误级别记录错误详情，方便后续排查问题。应避免使用此级别记录非常频繁和普遍的错误，以免日志信息过于混乱。

import logging

logging.error("This is an error message")

• CRITICAL（严重）级别：最高级别的日志级别。
  • 典型用例：用于记录严重错误和致命异常的信息，表示应用程序遇到了无法继续运行的重大问题。
  • 何时使用：当出现导致应用程序无法继续正常工作的重大错误时，使用严重级别记录错误详情。例如，无法初始化重要组件、关键资源不可用等。CRITICAL级别一般用于报警和紧急故障排除。

import logging

logging.critical("This is a critical message")

通过设置适当的日志级别，我们可以控制要记录的日志消息的严重程度。一般情况下，建议在生产环境中使用较高级别的日志级别，如INFO或WARNING，以记录关键信息和有潜在问题的情况，同时避免记录过多的调试信息。而在开发和调试阶段，可以使用DEBUG级别来记录更详细的调试信息，以便排查问题。

日志消息格式

用法介绍

通过格式化日志消息，可以将关键信息组合在一起，从而提供更具描述性的日志消息。例如，可以在日志消息中包含时间戳、模块名称、日志级别和具体消息，使得日志更易于阅读和理解。

在Python的logging模块中，使用字符串格式化语法来格式化日志消息。常用的格式化参数包括：

• %(asctime)s：日志记录的时间戳。
• %(name)s：Logger对象的名称。
• %(levelname)s：日志级别名称。
• %(message)s：日志具体消息。

可以使用这些格式化参数来定义自定义的日志消息格式，如添加时间戳、记录器名称等。通过使用basicConfig函数，可以设置日志消息的格式，并定义日志级别。

通过合理地格式化日志消息，可以清晰地记录和显示日志信息，并辅助于故障排查和系统分析。根据实际需求，可以使用不同的格式化参数来定制自己的日志格式，以更好地适应项目的需求。

代码示例

在Python的logging模块中，可以使用basicConfig函数或者Formatter类来设置和自定义日志消息的格式。以下演示了如何在logging模块中设置和自定义日志消息的格式：

1. 使用basicConfig函数设置日志消息格式：

   import logging
   
   logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
   
   logger = logging.getLogger('my_logger')
   logger.info('This is an info message')
   

   在上述示例中，通过调用basicConfig函数，设置了日志消息的格式为%(asctime)s - %(name)s - %(levelname)s - %(message)s。其中，%(asctime)s代表时间戳，%(name)s代表记录器名称，%(levelname)s代表日志级别，%(message)s代表具体的日志消息。然后，创建了一个名为my_logger的日志记录器，并记录了一条信息。

2. 使用Formatter类自定义日志消息格式：

   import logging
   
   formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
   
   logger = logging.getLogger('my_logger')
   logger.setLevel(logging.INFO)
   
   file_handler = logging.FileHandler('log.txt')
   file_handler.setFormatter(formatter)
   
   logger.addHandler(file_handler)
   
   logger.info('This is an info message')
   

   在上述示例中，创建了一个Formatter对象，使用'%(asctime)s - %(name)s - %(levelname)s - %(message)s'作为自定义的日志消息格式。然后，创建了一个名为my_logger的日志记录器，并设置了日志级别为INFO。接着，创建了一个FileHandler处理器，将日志消息输出到文件log.txt中，并设置其格式为先前定义的Formatter对象。最后，使用addHandler方法将处理器添加到日志记录器，并记录了一条信息。

通过使用basicConfig函数或者自定义Formatter类，我们可以设置和自定义日志消息的格式，以满足项目的需求。可以使用不同的格式化参数(如asctime、name、levelname、message等)来创建自己喜欢的格式，同时也可以添加自定义的字符、分隔符等来定制日志消息的样式。

日志的输出位置

日志的输出位置是指日志消息最终的存储或展示位置，包括控制台、文件、远程服务器等。不同的输出位置适用于不同的场景和需求：

1. 控制台输出：将日志消息输出到控制台是最简单和直接的方式，通常用于开发和调试阶段。通过在开发过程中实时查看程序的运行状态和日志输出，有助于快速定位问题和调试程序。在Python的logging模块中，可以通过添加StreamHandler处理器，并将其绑定到日志记录器上，从而实现日志消息的控制台输出。

2. 文件输出：将日志消息输出到文件是记录日志的常见方式，可以长期保留日志信息，用于故障排查、性能分析等。通过在将日志消息记录到文件中，可以记录系统运行时的各种状态信息，并随时可以进行检查和分析。在Python的logging模块中，可以通过添加FileHandler处理器，并指定文件路径来实现日志消息的文件输出。

3. 远程服务器输出：将日志消息发送到远程服务器是一种集中管理日志的方式，特别适用于分布式系统或云环境中的日志记录。通过将日志消息发送到远程服务器，可以将来自不同节点的日志信息集中展示和分析，更方便地进行整体监控和故障定位。在Python中，可以使用SocketHandler或者其他自定义的处理器，将日志消息发送到远程服务器。

4. 数据库输出：将日志消息存储到数据库中是一种灵活和可管理的方式，适用于需要长期存储大量日志信息的场景。通过将日志信息存储到数据库中，可以方便地进行检索、分析和报表生成，为系统的维护和监控提供便利。在Python中，可以通过自定义处理器，将日志消息存储到数据库中。

代码示例

可以使用Python的logging模块来配置日志记录输出到不同的目标位置，如控制台和文件。以下是一个演示如何配置logging将日志记录输出到不同目标位置的示例：

• import logging
  
  # 配置日志记录器
  logger = logging.getLogger('my_logger')
  logger.setLevel(logging.DEBUG)
  
  # 创建控制台处理器
  console_handler = logging.StreamHandler()
  console_handler.setLevel(logging.INFO)
  
  # 创建文件处理器
  file_handler = logging.FileHandler('log.txt')
  file_handler.setLevel(logging.DEBUG)
  
  # 定义格式器
  formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  
  # 将格式器添加到处理器
  console_handler.setFormatter(formatter)
  file_handler.setFormatter(formatter)
  
  # 将处理器添加到日志记录器
  logger.addHandler(console_handler)
  logger.addHandler(file_handler)
  
  # 记录日志
  logger.info('This is an info message')
  logger.debug('This is a debug message')
  

  在上述示例中：

  1. 创建了一个名为my_logger的日志记录器，并将日志级别设置为DEBUG。
  2. 创建了一个控制台处理器console_handler，并将其日志级别设置为INFO，表示只输出信息级别及以上的日志。
  3. 创建了一个文件处理器file_handler，输出的日志消息将写入到名为log.txt的文件中。将该处理器的日志级别设置为DEBUG，表示输出所有级别的日志。
  4. 定义了一个格式化器formatter，用于设置日志消息的格式。
  5. 将格式化器formatter添加到控制台处理器console_handler和文件处理器file_handler中。
  6. 将控制台处理器console_handler和文件处理器file_handler添加到日志记录器logger中。
  7. 最后，使用日志记录器logger记录了一条信息和一条调试消息。

  通过以上配置，日志信息将同时输出到控制台和写入到文件中。控制台处理器使用了INFO级别的日志级别过滤，只输出信息级别及以上的日志；文件处理器使用了DEBUG级别的日志级别过滤，输出所有级别的日志。可以根据实际需求，配置不同的处理器和不同的日志级别，实现将日志记录输出到不同的目标位置。

日志记录的高级功能

对日志记录进行过滤和处理

在Python的logging模块中，可以通过过滤器（Filter）和处理器（Handler）来对日志记录进行过滤和处理。以下是介绍如何对日志记录进行过滤和处理的示例：

1. 过滤日志记录：

   import logging
   
   class InfoFilter(logging.Filter):
       def filter(self, record):
           return record.levelno == logging.INFO
   
   logger = logging.getLogger('my_logger')
   logger.setLevel(logging.DEBUG)
   
   console_handler = logging.StreamHandler()
   console_handler.setLevel(logging.DEBUG)
   
   info_filter = InfoFilter()
   console_handler.addFilter(info_filter)
   
   logger.addHandler(console_handler)
   
   logger.debug('This is a debug message')
   logger.info('This is an info message')
   

   在上述示例中，定义了一个名为InfoFilter的过滤器，重写了filter方法，根据日志级别过滤出信息级别的日志记录。然后，通过addFilter方法将过滤器info_filter添加到控制台处理器console_handler中。最终，只输出了信息级别的日志记录。

2. 自定义处理器：

   import logging
   
   class CustomHandler(logging.StreamHandler):
       def emit(self, record):
           # 在日志消息前面添加自定义前缀
           record.msg = "[Custom Prefix] " + record.msg
           super().emit(record)
   
   logger = logging.getLogger('my_logger')
   logger.setLevel(logging.DEBUG)
   
   custom_handler = CustomHandler()
   custom_handler.setLevel(logging.DEBUG)
   
   logger.addHandler(custom_handler)
   
   logger.info('This is an info message')
   

   在上述示例中，定义了一个名为CustomHandler的自定义处理器，重写了emit方法，在日志消息前面添加了自定义的前缀。然后，将自定义处理器custom_handler添加到日志记录器logger中。最终，所有通过该处理器记录的日志消息都会在前面添加自定义的前缀。

在多个模块中使用同一个日志记录器

在多个模块中使用同一个日志记录器可以确保日志消息在整个应用程序中一致地记录和管理，以及避免创建多个相同的日志记录器。以下是讨论如何在多个模块中使用同一个日志记录器的方法：

# main.py
import logging
import module1
import module2

# 创建一个名为my_logger的日志记录器
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 创建格式化器
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)

# 将处理器添加到日志记录器
logger.addHandler(console_handler)

# 在module1和module2中使用同一个日志记录器
module1.do_something()
module2.do_another_thing()

# module1.py
import logging

# 获取已经创建的日志记录器
logger = logging.getLogger('my_logger')

def do_something():
    logger.info('This is a message from module1')

# module2.py
import logging

# 获取已经创建的日志记录器
logger = logging.getLogger('my_logger')

def do_another_thing():
    logger.info('This is a message from module2')

在上述示例中，主模块main.py创建了一个名为my_logger的日志记录器，并配置了控制台处理器。然后，在module1和module2中分别通过logging.getLogger('my_logger')的方式获取了同一个日志记录器实例。这样，无论在哪个模块中记录日志，都会使用同一个日志记录器，并且遵循主模块中配置的日志记录器设置。

通过在不同的模块中引用同一个日志记录器实例，可以实现日志消息的一致记录和管理，避免了在每个模块中都创建和配置相同的日志记录器。这样可以更好地组织和管理日志记录器，并确保日志消息在整个应用程序中的一致性。

总结

相信通过阅读本文，你已经对logging库有了一个全面的了解，并能够在自己的Python项目中合理地使用和配置日志记录功能。但是，logging库还有更多高级用法和最佳实践等待你去探索和应用。