Python的logging模块是标准库中强大而灵活的日志记录工具，它提供了完整的日志记录解决方案，适用于从简单脚本到大型企业级应用的各种场景。

基础概念

日志级别

logging模块定义了五个标准的日志级别，按严重程度递增：

import logging
# 五个标准日志级别（从低到高）
logging.DEBUG # 调试信息，最详细
logging.INFO # 一般信息
logging.WARNING # 警告信息
logging.ERROR # 错误信息
logging.CRITICAL # 严重错误

核心组件

1. Logger: 日志记录器，应用程序通过它来记录日志消息
2. Handler: 处理器，决定日志消息的输出目的地
3. Formatter: 格式化器，定义日志消息的输出格式
4. Filter: 过滤器，控制哪些日志消息应该被输出

快速开始

简单使用

最简单的使用方式是直接调用logging模块提供的函数：

import logging
# 配置基本设置
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s'
)
# 记录不同级别的日志
logging.debug("这是一条调试信息")
logging.info("程序正常运行")
logging.warning("这是一个警告")
logging.error("发生了一个错误")
logging.critical("发生严重错误")

输出结果：

2024-01-15 10:30:45,123 - DEBUG - 这是一条调试信息
2024-01-15 10:30:45,124 - INFO - 程序正常运行
2024-01-15 10:30:45,125 - WARNING - 这是一个警告
2024-01-15 10:30:45,126 - ERROR - 发生了一个错误
2024-01-15 10:30:45,127 - CRITICAL - 发生严重错误

详细配置使用

创建自定义Logger

import logging
# 创建logger对象
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)
# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# 创建文件处理器
file_handler = logging.FileHandler('app.log')
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
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# 使用logger记录日志
logger.debug("调试信息")
logger.info("一般信息")
logger.warning("警告信息")
logger.error("错误信息")
logger.critical("严重错误")

多模块项目中的日志配置

# main.py
import logging
import logging.config
# 配置日志
logging.config.dictConfig({
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
},
},
'handlers': {
'default': {
'level': 'INFO',
'formatter': 'standard',
'class': 'logging.StreamHandler',
},
'file': {
'level': 'DEBUG',
'formatter': 'standard',
'class': 'logging.FileHandler',
'filename': 'application.log',
},
},
'loggers': {
'': { # 根logger
'handlers': ['default', 'file'],
'level': 'DEBUG',
'propagate': False
}
}
})
# 获取logger
logger = logging.getLogger(__name__)
def main():
logger.info("应用程序启动")
from module1 import process_data
process_data()
logger.info("应用程序结束")
if __name__ == "__main__":
main()

# module1.py
import logging
logger = logging.getLogger(__name__)
def process_data():
logger.info("开始处理数据")
try:
# 模拟数据处理
result = 10 / 0 # 这会引发异常
logger.debug(f"计算结果: {result}")
except Exception as e:
logger.error(f"数据处理失败: {e}", exc_info=True)
finally:
logger.info("数据处理完成")

高级功能

异常信息记录

import logging
logging.basicConfig(level=logging.DEBUG)
def divide_numbers(a, b):
try:
result = a / b
logging.info(f"除法运算成功: {a} / {b} = {result}")
return result
except ZeroDivisionError:
logging.error("除零错误发生", exc_info=True)
raise
except Exception:
logging.exception("未知错误发生") # 自动记录异常堆栈
raise
# 测试
try:
divide_numbers(10, 0)
except:
pass

自定义格式化器

import logging
import json
class JSONFormatter(logging.Formatter):
def format(self, record):
log_entry = {
'timestamp': self.formatTime(record),
'level': record.levelname,
'logger': record.name,
'message': record.getMessage(),
'module': record.module,
'function': record.funcName,
'line': record.lineno
}
if hasattr(record, 'user_id'):
log_entry['user_id'] = record.user_id

return json.dumps(log_entry)
# 使用自定义格式化器
logger = logging.getLogger('json_logger')
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logger.addHandler(handler)
# 添加自定义字段
def log_with_user(user_id):
logger.info("用户执行操作", extra={'user_id': user_id})
log_with_user(12345)

多处理器配置

import logging
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
# 创建logger
logger = logging.getLogger('rotating_logger')
logger.setLevel(logging.DEBUG)
# 创建轮转文件处理器（按文件大小）
rotating_handler = RotatingFileHandler(
'app.log', maxBytes=1024*1024, backupCount=5 # 1MB大小限制，保留5个备份
)
rotating_handler.setLevel(logging.DEBUG)
# 创建时间轮转文件处理器（按时间）
time_handler = TimedRotatingFileHandler(
'daily.log', when='midnight', interval=1, backupCount=7 # 每天轮转，保留7天
)
time_handler.setLevel(logging.INFO)
# 配置格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

rotating_handler.setFormatter(formatter)
time_handler.setFormatter(formatter)
# 添加处理器
logger.addHandler(rotating_handler)
logger.addHandler(time_handler)
# 测试日志轮转
for i in range(1000):
logger.debug(f"这是第 {i} 条日志消息")

实际应用示例

Web应用日志配置

import logging
from logging.handlers import RotatingFileHandler
import os
class WebAppLogger:
def __init__(self, name='webapp'):
self.logger = logging.getLogger(name)
self.logger.setLevel(logging.DEBUG)

# 确保日志目录存在
log_dir = 'logs'
if not os.path.exists(log_dir):
os.makedirs(log_dir)

# 创建不同级别的处理器
self._setup_handlers()

def _setup_handlers(self):
# 错误日志文件处理器
error_handler = RotatingFileHandler(
'logs/error.log', maxBytes=10*1024*1024, backupCount=5
)
error_handler.setLevel(logging.ERROR)
error_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s - %(pathname)s:%(lineno)d'
)

error_handler.setFormatter(error_formatter)

# 常规日志处理器
info_handler = RotatingFileHandler(
'logs/app.log', maxBytes=5*1024*1024, backupCount=3
)
info_handler.setLevel(logging.INFO)
info_formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s'
)
info_handler.setFormatter(info_formatter)

# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s'
)

console_handler.setFormatter(console_formatter)

# 添加处理器
self.logger.addHandler(error_handler)
self.logger.addHandler(info_handler)
self.logger.addHandler(console_handler)

def get_logger(self):
return self.logger
# 使用示例
web_logger = WebAppLogger().get_logger()
def handle_request(request):
web_logger.info(f"接收到请求: {request}")
try:
# 处理请求逻辑
result = process_request(request)
web_logger.info(f"请求处理成功: {result}")
return result
except Exception as e:
web_logger.error(f"请求处理失败: {request}, 错误: {e}", exc_info=True)
raise
def process_request(request):
# 模拟请求处理
if request == "invalid":
raise ValueError("无效请求")
return f"处理结果: {request}"

配置文件方式

# logging_config.py
import logging.config
LOGGING_CONFIG = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'verbose': {
'format': '{asctime} [{levelname}] {name}: {message}',
'style': '{',
'datefmt': '%Y-%m-%d %H:%M:%S'
},
'simple': {
'format': '{levelname} {message}',
'style': '{'
}
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'level': 'INFO',
'formatter': 'simple',
'stream': 'ext://sys.stdout'
},
'file': {
'class': '
logging.handlers.RotatingFileHandler',
'level': 'DEBUG',
'formatter': 'verbose',
'filename': 'logs/app.log',
'maxBytes': 10485760, # 10MB
'backupCount': 5,
'encoding': 'utf8'
}
},
'loggers': {
'myapp': {
'level': 'DEBUG',
'handlers': ['console', 'file'],
'propagate': False
}
},
'root': {
'level': 'WARNING',
'handlers': ['console']
}
}
# 应用配置
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger('myapp')
# 使用
logger.debug("这是调试信息")
logger.info("这是普通信息")
logger.warning("这是警告信息")

最佳实践

1. 合理设置日志级别

import logging
# 在开发环境中使用DEBUG级别
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
else:
# 在生产环境中使用INFO级别
logging.basicConfig(level=logging.INFO)

2. 结构化日志记录

import logging
logger = logging.getLogger(__name__)
def user_login(username, ip_address):
logger.info(
"用户登录",
extra={
'event': 'user_login',
'username': username,
'ip': ip_address,
'timestamp': datetime.now().isoformat()
}
)

3. 性能考虑

import logging
logger = logging.getLogger(__name__)
# 避免不必要的字符串格式化
# 不好的做法
logger.debug("用户 %s 的数据: %s" % (username, user_data))
# 好的做法
logger.debug("用户 %s 的数据: %s", username, user_data)
# 或者使用惰性求值
logger.debug("复杂计算结果: %s", lambda: expensive_calculation())

logging模块是Python中不可或缺的日志工具，通过合理配置可以满足各种复杂应用场景的需求，为应用程序的调试、监控和维护提供强有力的支撑。