Pythonlogging模块使用详解

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Python logging模块使用教程》，聊聊，希望可以帮助到正在努力赚钱的你。

使用logging模块记录执行日志需先导入模块并调用logging.basicConfig()进行基础配置，包括设置日志级别、格式、输出文件和写入模式；2. 配置后通过logging.debug()、logging.info()、logging.error()等方法在代码中记录不同级别的日志信息；3. 可创建Logger、Handler和Formatter对象实现更高级配置，如将日志同时输出到文件和控制台，并为不同模块使用logging.getLogger(__name__)创建独立Logger；4. 在多进程环境中，应使用logging.handlers.QueueHandler与logging.handlers.QueueListener结合队列机制，确保日志写入的线程安全与一致性，避免多进程同时写入导致的日志混乱。

Python命令如何使用logging模块记录执行日志？简单来说，就是利用logging模块，在你的Python脚本里插入一些记录信息的代码，这样程序运行的时候，就能把关键信息保存下来，方便你排查问题或者分析程序运行情况。

logging模块提供了灵活的配置，可以控制日志级别、输出格式和存储位置。下面详细说明操作方法。

解决方案

配置logging模块

首先，你需要导入logging模块，并进行基本配置。配置内容包括日志级别、日志格式、输出位置等。

import logging

# 配置日志级别，低于DEBUG级别的日志不会被记录
logging.basicConfig(level=logging.DEBUG,
                    # 日志格式，包括时间、级别、文件名、行号、消息
                    format='%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s',
                    # 日志输出到文件，可以指定文件名
                    filename='my_program.log',
                    # 文件写入模式，'w'表示覆盖，'a'表示追加
                    filemode='a')

这段代码做了几件事：

• logging.basicConfig(): 这是最基本的配置方法。
• level=logging.DEBUG: 设置日志级别为DEBUG，意味着DEBUG、INFO、WARNING、ERROR、CRITICAL级别的日志都会被记录。你可以根据需要调整这个级别。
• format='%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s': 定义日志信息的格式。%(asctime)s是时间，%(levelname)s是日志级别，%(filename)s是文件名，%(lineno)d是行号，%(message)s是日志消息。
• filename='my_program.log': 指定日志输出到文件my_program.log。如果不指定，默认输出到控制台。
• filemode='a': 设置文件写入模式为追加。每次运行程序，新的日志信息都会追加到文件末尾。如果设置为'w'，每次运行都会覆盖之前的内容。

记录日志信息

配置好logging模块后，就可以在代码中插入日志记录语句了。

import logging

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s',
                    filename='my_program.log',
                    filemode='a')

def my_function(x, y):
    logging.debug(f"Function my_function called with x={x}, y={y}")
    try:
        result = x / y
        logging.info(f"Result of x / y is {result}")
        return result
    except ZeroDivisionError:
        logging.error("Division by zero!")
        return None

if __name__ == '__main__':
    my_function(10, 2)
    my_function(5, 0)

这段代码演示了如何使用不同级别的日志记录：

• logging.debug(): 记录调试信息，通常用于开发阶段。
• logging.info(): 记录一般信息，用于程序正常运行时的信息。
• logging.error(): 记录错误信息，用于程序出现错误时的信息。

当程序运行时，日志信息会被写入到my_program.log文件中。

更高级的配置：Logger、Handler和Formatter

logging.basicConfig()提供了一些基本的配置，但logging模块的功能远不止于此。你可以使用Logger、Handler和Formatter进行更高级的配置。

• Logger: 负责接收日志信息，并传递给Handler。
• Handler: 负责将日志信息输出到不同的目标，比如文件、控制台、网络等。
• Formatter: 负责格式化日志信息。

下面是一个更复杂的例子：

import logging

# 创建一个logger
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建一个handler，用于输出到文件
file_handler = logging.FileHandler('my_program.log', mode='a')
file_handler.setLevel(logging.INFO)

# 创建一个handler，用于输出到控制台
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 创建一个formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 将formatter添加到handler
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 将handler添加到logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

def my_function(x, y):
    logger.debug(f"Function my_function called with x={x}, y={y}")
    try:
        result = x / y
        logger.info(f"Result of x / y is {result}")
        return result
    except ZeroDivisionError:
        logger.error("Division by zero!")
        return None

if __name__ == '__main__':
    my_function(10, 2)
    my_function(5, 0)

这个例子中，我们创建了一个名为my_logger的logger，并添加了两个handler：一个用于输出到文件，一个用于输出到控制台。 文件handler只记录INFO级别及以上的日志，而控制台handler记录DEBUG级别及以上的日志。 这样，你就可以根据需要，将不同级别的日志输出到不同的地方。

如何自定义日志格式？

你可以通过logging.Formatter来自定义日志格式。 Formatter接受一个格式字符串作为参数，格式字符串中可以使用各种占位符来表示不同的日志信息。

常用的占位符包括：

• %(asctime)s: 日志产生的时间
• %(name)s: logger的名字
• %(levelname)s: 日志级别
• %(message)s: 日志消息
• %(filename)s: 文件名
• %(lineno)d: 行号
• %(module)s: 模块名
• %(funcName)s: 函数名
• %(process)d: 进程ID
• %(thread)d: 线程ID

例如，你可以使用以下格式字符串：

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s')

这将生成包含时间、logger名字、日志级别、文件名、行号和消息的日志信息。

如何根据不同的模块使用不同的Logger？

在大型项目中，通常会将代码分成多个模块。 为了方便管理日志，可以为每个模块创建一个Logger。

# module1.py
import logging

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# 创建一个handler，用于输出到文件
file_handler = logging.FileHandler('my_program.log', mode='a')
file_handler.setLevel(logging.INFO)

# 创建一个formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 将formatter添加到handler
file_handler.setFormatter(formatter)

# 将handler添加到logger
logger.addHandler(file_handler)

def my_function():
    logger.debug("my_function in module1 called")

# module2.py
import logging
from module1 import my_function

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# 创建一个handler，用于输出到文件
file_handler = logging.FileHandler('my_program.log', mode='a')
file_handler.setLevel(logging.INFO)

# 创建一个formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 将formatter添加到handler
file_handler.setFormatter(formatter)

# 将handler添加到logger
logger.addHandler(file_handler)

def another_function():
    logger.debug("another_function in module2 called")
    my_function()

if __name__ == '__main__':
    another_function()

在这个例子中，module1.py和module2.py都创建了自己的Logger，logger的名字分别是module1和module2。 这样，在日志信息中就可以区分来自不同模块的日志。 使用__name__作为Logger的名字是一个常用的技巧，因为__name__会自动设置为模块的名字。

如何在多线程或多进程中使用logging模块？

在多线程或多进程环境中，需要注意logging模块的线程安全问题。 logging模块本身是线程安全的，但如果多个线程或进程同时写入同一个文件，可能会导致日志信息混乱。

为了避免这个问题，可以使用以下方法：

• 使用logging.handlers.RotatingFileHandler或logging.handlers.TimedRotatingFileHandler: 这两种Handler可以自动分割日志文件，避免单个文件过大，也可以避免多个线程或进程同时写入同一个文件。
• 使用logging.handlers.QueueHandler和logging.handlers.QueueListener: 这种方法将日志信息发送到一个队列中，然后由一个单独的线程或进程从队列中读取日志信息并写入文件。 这样可以避免多个线程或进程同时写入同一个文件。

这里给出一个使用logging.handlers.QueueHandler和logging.handlers.QueueListener的例子：

import logging
import logging.handlers
import multiprocessing
import queue
import time

def worker_process(queue):
    # 配置worker进程的logger
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    handler = logging.handlers.QueueHandler(queue)  # Use QueueHandler
    logger.addHandler(handler)

    # 记录一些日志
    logger.info('Worker process started')
    logger.debug('Debugging message from worker')
    logger.warning('Warning message from worker')
    logger.error('Error message from worker')
    logger.info('Worker process finished')

def listener_process(queue):
    # 配置listener进程的logger
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)

    # 创建一个FileHandler来写入日志文件
    file_handler = logging.FileHandler('multiprocessing_example.log', mode='a')
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)

    # 使用QueueListener来监听队列并将日志记录到handler
    listener = logging.handlers.QueueListener(queue, file_handler)
    listener.start()
    listener.join()

if __name__ == '__main__':
    # 创建一个队列
    log_queue = queue.Queue(-1)

    # 创建并启动listener进程
    listener = multiprocessing.Process(target=listener_process, args=(log_queue,))
    listener.start()

    # 创建并启动多个worker进程
    processes = []
    for i in range(3):
        process = multiprocessing.Process(target=worker_process, args=(log_queue,))
        processes.append(process)
        process.start()

    # 等待所有worker进程完成
    for process in processes:
        process.join()

    # 发送一个None到队列中，表示listener可以停止
    log_queue.put(None)
    listener.join()

    print("Finished!")

这个例子中，我们创建了一个listener进程和一个或多个worker进程。 worker进程将日志信息发送到一个队列中，listener进程从队列中读取日志信息并写入文件。 这样可以避免多个进程同时写入同一个文件，保证日志信息的完整性和一致性。 注意，需要在listener进程中调用listener.start()和listener.join()，以启动和等待listener线程。 还需要在所有worker进程完成后，向队列中发送一个None，以通知listener进程停止。

总而言之，Python的logging模块是一个非常强大和灵活的工具，可以帮助你记录程序的运行信息，方便你排查问题和分析程序运行情况。 你可以根据自己的需要，选择合适的配置方式和日志级别，以及使用不同的Handler和Formatter，来实现各种各样的日志记录需求。

文中关于Python,Python编程,Python命令的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Pythonlogging模块使用详解》文章吧，也可关注golang学习网公众号了解相关技术文章。