Python日志保存案例如何保存日志文件

wen python案例 2026-06-29 277

本文目录导读：

基础日志保存示例
按大小轮转的日志文件
按时轮转的日志文件
结合配置文件的高级日志系统
多模块日志管理
性能优化的异步日志
实用建议

我来为您提供几个Python日志保存的实用案例：

基础日志保存示例

import logging
import os
from datetime import datetime
# 创建日志目录
log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)
# 生成带时间戳的日志文件名
log_file = os.path.join(log_dir, f"app_{datetime.now().strftime('%Y%m%d')}.log")
# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(log_file, encoding='utf-8'),  # 保存到文件
        logging.StreamHandler()  # 同时输出到控制台
    ]
)
# 创建logger
logger = logging.getLogger(__name__)
# 使用日志
logger.info("程序启动")
logger.warning("这是一个警告信息")
logger.error("发生错误")

按大小轮转的日志文件

import logging
from logging.handlers import RotatingFileHandler
# 配置轮转日志
handler = RotatingFileHandler(
    'app.log',           # 日志文件名
    maxBytes=1024*1024,  # 每个日志文件最大1MB
    backupCount=5,       # 保留5个备份文件
    encoding='utf-8'
)
# 设置格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# 配置logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
# 使用示例
for i in range(1000):
    logger.info(f"这是第{i}条日志信息")

按时轮转的日志文件

import logging
from logging.handlers import TimedRotatingFileHandler
import time
# 配置时间轮转日志
handler = TimedRotatingFileHandler(
    'timed_app.log',     # 日志文件名
    when='midnight',     # 每天午夜轮转
    interval=1,          # 轮转间隔
    backupCount=7,       # 保留7天的日志
    encoding='utf-8'
)
# 设置格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# 配置logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
# 使用示例
logger.info("这条日志会按天轮转")

结合配置文件的高级日志系统

import logging
import logging.config
import json
import os
class LoggerManager:
    def __init__(self, config_file='logging_config.json'):
        self.config_file = config_file
        self.setup_logging()
    def setup_logging(self):
        """配置日志系统"""
        # 默认配置
        default_config = {
            'version': 1,
            'disable_existing_loggers': False,
            'formatters': {
                'standard': {
                    'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
                },
                'detailed': {
                    'format': '%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(message)s'
                }
            },
            'handlers': {
                'console': {
                    'class': 'logging.StreamHandler',
                    'level': 'DEBUG',
                    'formatter': 'standard'
                },
                'file': {
                    'class': 'logging.handlers.RotatingFileHandler',
                    'level': 'INFO',
                    'formatter': 'detailed',
                    'filename': 'logs/application.log',
                    'maxBytes': 10485760,  # 10MB
                    'backupCount': 5,
                    'encoding': 'utf8'
                },
                'error_file': {
                    'class': 'logging.handlers.RotatingFileHandler',
                    'level': 'ERROR',
                    'formatter': 'detailed',
                    'filename': 'logs/error.log',
                    'maxBytes': 10485760,
                    'backupCount': 3,
                    'encoding': 'utf8'
                }
            },
            'root': {
                'level': 'INFO',
                'handlers': ['console', 'file']
            }
        }
        # 保存默认配置
        if not os.path.exists(self.config_file):
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(default_config, f, indent=2)
        # 应用配置
        logging.config.dictConfig(default_config)
    @staticmethod
    def get_logger(name):
        """获取logger实例"""
        return logging.getLogger(name)
# 使用示例
if __name__ == "__main__":
    # 初始化日志管理器
    log_manager = LoggerManager()
    # 获取logger
    logger = log_manager.get_logger(__name__)
    # 记录不同级别的日志
    logger.debug("调试信息")
    logger.info("正常信息")
    logger.warning("警告信息")
    logger.error("错误信息")
    logger.critical("严重错误")

多模块日志管理

# utils/logger.py
import logging
import os
from logging.handlers import RotatingFileHandler
class AppLogger:
    _instances = {}
    def __new__(cls, name='root'):
        if name not in cls._instances:
            cls._instances[name] = super().__new__(cls)
            cls._instances[name]._setup_logger(name)
        return cls._instances[name]
    def _setup_logger(self, name):
        """配置logger"""
        # 创建日志目录
        log_dir = 'logs'
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)
        # 创建logger
        self.logger = logging.getLogger(name)
        self.logger.setLevel(logging.DEBUG)
        # 防止重复添加handler
        if not self.logger.handlers:
            # 文件处理器
            file_handler = RotatingFileHandler(
                os.path.join(log_dir, f'{name}.log'),
                maxBytes=10*1024*1024,
                backupCount=5,
                encoding='utf-8'
            )
            file_handler.setLevel(logging.DEBUG)
            # 控制台处理器
            console_handler = logging.StreamHandler()
            console_handler.setLevel(logging.INFO)
            # 格式化器
            formatter = logging.Formatter(
                '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
            )
            file_handler.setFormatter(formatter)
            console_handler.setFormatter(formatter)
            # 添加处理器
            self.logger.addHandler(file_handler)
            self.logger.addHandler(console_handler)
    def log(self, level, message, *args, **kwargs):
        """记录日志"""
        self.logger.log(level, message, *args, **kwargs)
# 在其他模块中使用
from utils.logger import AppLogger
logger = AppLogger('module_a').logger
logger.info("模块A开始运行")
logger.error("模块A发生错误")

性能优化的异步日志

import logging
import queue
import threading
from logging.handlers import QueueHandler, QueueListener
import time
class AsyncLogger:
    def __init__(self, log_file='async_app.log'):
        self.log_file = log_file
        self.setup_async_logging()
    def setup_async_logging(self):
        """配置异步日志"""
        # 创建日志队列
        log_queue = queue.Queue(-1)
        # 创建处理器
        file_handler = logging.FileHandler(self.log_file, encoding='utf-8')
        file_handler.setFormatter(logging.Formatter(
            '%(asctime)s - %(levelname)s - %(message)s'
        ))
        # 创建队列监听器
        self.listener = QueueListener(log_queue, file_handler, respect_handler_level=True)
        # 配置root logger使用队列处理器
        queue_handler = QueueHandler(log_queue)
        root_logger = logging.getLogger()
        root_logger.addHandler(queue_handler)
        root_logger.setLevel(logging.INFO)
        # 启动监听器
        self.listener.start()
    def stop(self):
        """停止异步日志"""
        self.listener.stop()
# 使用示例
async_logger = AsyncLogger()
logger = logging.getLogger(__name__)
# 高性能日志记录
for i in range(10000):
    logger.info(f"高性能异步日志 - {i}")
    # 不需要等待写入完成
async_logger.stop()  # 程序结束时停止

实用建议

日志级别选择：
- DEBUG: 详细调试信息
- INFO: 正常运行信息
- WARNING: 警告信息
- ERROR: 错误信息
- CRITICAL: 严重错误
日志文件管理：
- 使用轮转机制避免日志文件过大
- 定期清理过期日志
- 按日期或大小组织日志文件
性能考虑：
- 生产环境避免使用DEBUG级别
- 考虑使用异步日志处理
- 合理设置日志缓存

这些案例涵盖了从基础到高级的日志保存需求,您可以根据实际场景选择合适的方案。

本文地址： https://www.bmjup.com/post/11991.html