Python logging模块

文章目录

[Python `logging` 模块](#Python logging 模块)
日志级别
基本用法
日志格式化
输出到文件
创建自定义日志记录器
[通过 JSON 或 YAML 文件配置 Logging 模块](#通过 JSON 或 YAML 文件配置 Logging 模块)
- [1 通过 JSON 文件配置](#1 通过 JSON 文件配置)
- [2 通过 YAML 文件配置](#2 通过 YAML 文件配置)
[使用 Logging 模块管理多模块日志](#使用 Logging 模块管理多模块日志)
- [1. 主模块 `mainModule.py`](#1. 主模块 mainModule.py)
- [2. 子模块 `subModule.py`](#2. 子模块 subModule.py)
- [3. 日志输出示例](#3. 日志输出示例)
总结

Python `logging` 模块

logging 模块是 Python 标准库的一部分，用于记录应用程序的运行信息。通过记录日志，可以帮助开发者追踪代码的执行过程，诊断问题，和分析程序性能。本文将深入探讨 logging 模块的使用，包括日志级别、格式化和输出到文件等功能。

日志级别

logging 模块提供了不同的日志级别，用于表示信息的重要性：

日志级别	数值	描述
DEBUG	10	详细信息，通常用于调试
INFO	20	常规信息，表明程序正常运行
WARNING	30	警告信息，表示某些问题可能会导致错误
ERROR	40	错误信息，程序出现问题
CRITICAL	50	严重错误，程序可能无法继续运行

基本用法

python 复制代码

import logging

# 设置日志级别为 DEBUG
logging.basicConfig(level=logging.DEBUG)

# 记录不同级别的日志
logging.debug("这是调试信息")
logging.info("这是普通信息")
logging.warning("这是警告信息")
logging.error("这是错误信息")
logging.critical("这是严重错误")

日志格式化

我们可以自定义日志的输出格式，例如包含时间戳、日志级别和消息内容。

python 复制代码

import logging

# 自定义日志格式
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.DEBUG)

logging.info("这是一条信息")

输出到文件

通过配置 filename 参数，可以将日志信息输出到文件中，而不是控制台。

python 复制代码

import logging

# 将日志输出到文件
logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

logging.debug("调试信息会写入文件")
logging.info("普通信息也会写入文件")

创建自定义日志记录器

可以创建自定义的日志记录器，以便更灵活地管理日志输出。

python 复制代码

import logging

# 创建自定义日志记录器
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

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

# 创建文件处理器
fh = logging.FileHandler('my_logger.log')
fh.setLevel(logging.DEBUG)

# 创建格式化器并添加到处理器
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
fh.setFormatter(formatter)

# 将处理器添加到记录器
logger.addHandler(ch)
logger.addHandler(fh)

logger.debug("调试信息，控制台和文件都能看到")
logger.info("普通信息，只在控制台上显示")

好的，以下是关于通过 JSON 和 YAML 文件配置 Python logging 模块的整理和优化，适合加入到你的博文中。

通过 JSON 或 YAML 文件配置 Logging 模块

尽管可以在 Python 代码中直接配置 logging 模块，但使用配置文件可以提供更大的灵活性。在 Python 2.7 及以后的版本中，可以通过字典加载配置，因此可以使用 JSON 或 YAML 文件来配置日志记录。

1 通过 JSON 文件配置

下面是一个示例 JSON 配置文件，定义了日志格式、处理器和记录器。

JSON 配置文件 (logging_config.json)

json 复制代码

{
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
        "simple": {
            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        }
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "level": "DEBUG",
            "formatter": "simple",
            "stream": "ext://sys.stdout"
        },
        "info_file_handler": {
            "class": "logging.handlers.RotatingFileHandler",
            "level": "INFO",
            "formatter": "simple",
            "filename": "info.log",
            "maxBytes": 10485760,
            "backupCount": 20,
            "encoding": "utf8"
        },
        "error_file_handler": {
            "class": "logging.handlers.RotatingFileHandler",
            "level": "ERROR",
            "formatter": "simple",
            "filename": "errors.log",
            "maxBytes": 10485760,
            "backupCount": 20,
            "encoding": "utf8"
        }
    },
    "loggers": {
        "my_module": {
            "level": "ERROR",
            "handlers": ["info_file_handler"],
            "propagate": "no"
        }
    },
    "root": {
        "level": "INFO",
        "handlers": ["console", "info_file_handler", "error_file_handler"]
    }
}

通过 JSON 加载配置

python 复制代码

import json
import logging
import logging.config

def setup_logging(json_file='logging_config.json'):
    with open(json_file, 'r') as f:
        config = json.load(f)
        logging.config.dictConfig(config)

setup_logging()

2 通过 YAML 文件配置

YAML 文件相比 JSON 更加简洁易读，可以方便地配置日志记录。

YAML 配置文件 (logging_config.yaml)

yaml 复制代码

version: 1
disable_existing_loggers: False
formatters:
    simple:
        format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
handlers:
    console:
        class: logging.StreamHandler
        level: DEBUG
        formatter: simple
        stream: ext://sys.stdout
    info_file_handler:
        class: logging.handlers.RotatingFileHandler
        level: INFO
        formatter: simple
        filename: info.log
        maxBytes: 10485760
        backupCount: 20
        encoding: utf8
    error_file_handler:
        class: logging.handlers.RotatingFileHandler
        level: ERROR
        formatter: simple
        filename: errors.log
        maxBytes: 10485760
        backupCount: 20
        encoding: utf8
loggers:
    my_module:
        level: ERROR
        handlers: [info_file_handler]
        propagate: no
root:
    level: INFO
    handlers: [console, info_file_handler, error_file_handler]

通过 YAML 加载配置

python 复制代码

import yaml
import logging.config
import os

def setup_logging(default_path='logging.yaml', default_level=logging.INFO, env_key='LOG_CFG'):
    path = default_path
    value = os.getenv(env_key, None)
    if value:
        path = value
    if os.path.exists(path):
        with open(path, 'r') as f:
            config = yaml.safe_load(f)
            logging.config.dictConfig(config)
    else:
        logging.basicConfig(level=default_level)

def func():
    logging.info("开始执行函数")
    logging.info("执行中")
    logging.info("函数执行结束")

if __name__ == "__main__":
    setup_logging(default_path='logging.yaml')
    func()

使用 Logging 模块管理多模块日志

在构建复杂的 Python 应用时，有效的日志管理至关重要。借助 logging 模块，我们可以在多个模块之间共享日志配置，并通过层级结构组织日志记录，从而提高代码的可维护性。

1. 主模块 `mainModule.py`

在主模块中，我们首先创建并配置一个日志记录器，以便在整个应用中进行日志记录。

python 复制代码

import logging
import subModule

# 创建主日志记录器
logger = logging.getLogger("mainModule")
logger.setLevel(logging.INFO)

# 配置文件处理器
handler = logging.FileHandler("log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)

# 配置控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(formatter)

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

# 记录应用流程
logger.info("创建子模块实例")
sub_module_instance = subModule.SubModuleClass()
logger.info("调用子模块方法")
sub_module_instance.doSomething()
logger.info("完成子模块方法调用")
logger.info("调用子模块的其他函数")
subModule.some_function()
logger.info("完成所有操作")

2. 子模块 `subModule.py`

在子模块中，我们创建一个子日志记录器，以便记录该模块内的日志信息。

python 复制代码

import logging

# 创建子模块日志记录器
module_logger = logging.getLogger("mainModule.sub")

class SubModuleClass:
    def __init__(self):
        self.logger = logging.getLogger("mainModule.sub.module")
        self.logger.info("SubModuleClass 实例创建完成")

    def doSomething(self):
        self.logger.info("执行某项操作")
        temp_list = []
        temp_list.append(1)
        self.logger.debug(f"当前列表内容: {temp_list}")
        self.logger.info("操作执行完毕")

def some_function():
    module_logger.info("调用了 some_function 函数")

3. 日志输出示例

运行上述代码后，您将看到如下日志输出（包括控制台和 log.txt 文件）：

2023-10-23 15:05:07,427 - mainModule - INFO - 创建子模块实例
2023-10-23 15:05:07,427 - mainModule.sub.module - INFO - SubModuleClass 实例创建完成
2023-10-23 15:05:07,427 - mainModule - INFO - 调用子模块方法
2023-10-23 15:05:07,427 - mainModule.sub.module - INFO - 执行某项操作
2023-10-23 15:05:07,427 - mainModule.sub.module - INFO - 操作执行完毕
2023-10-23 15:05:07,427 - mainModule - INFO - 完成子模块方法调用
2023-10-23 15:05:07,427 - mainModule - INFO - 调用子模块的其他函数
2023-10-23 15:05:07,427 - mainModule.sub - INFO - 调用了 some_function 函数
2023-10-23 15:05:07,428 - mainModule - INFO - 完成所有操作

总结

logging 模块是 Python 中强大而灵活的日志记录工具。通过设置日志级别、格式化输出和自定义记录器，开发者可以轻松追踪应用程序的运行状态。合理地使用日志，有助于更好地维护和调试代码。

Python logging模块

文章目录