一、日志级别

等级	数值	描述
CRITICAL	50	严重错误，程序不能正常运行。
FATAL	50	同 CRITICAL。
ERROR	40	错误，程序的某些功能不能正常运行。
WARNING	30	警告，表明已经或即将发生的意外（例如：磁盘空间不足），但程序仍按照预期运行。
WARN	30	同 WARNING。
INFO	20	关键信息，程序按照预期运行。
DEBUG	10	详细信息，在我们调试程序时使用。
NOTSET	0	不设置。

默认的级别的WARNING，意味着只会追踪该级别及以上的事件，除非更改日志配置。

二、logging.basicConfig(**kwargs)

参数	描述
filename	指定输出日志的文件名，如果指定了这个参数，实际上会启用`FileHandler`，而不再是`StreamHandler`，这样日志就输出到文件，而不输出到控制台了。
filemode	指定文件打开模式，默认模式为“a”。
format	指定日志信息的输出格式，参数说明如下： %(name)s：Logger的名称，默认为“root”。 %(levelno)s：数字类型的日志级别。 %(levelname)s：文本类型的日志级别。 %(pathname)s：调用日志输出函数的模块的完整路径。 %(filename)s：调用日志输出函数的模块的文件名。 %(module)s：调用日志输出函数的模块名。 %(lineno)d：调用日志输出函数的语句所在的代码行。 %(funcName)s：调用日志输出函数的函数名。 %(created)f：当前时间，用 UNIX 标准的表示时间的浮点数表示。 %(asctime)s：字符串形式的当前时间，默认格式是“2023-08-28 14:02:26,719”，逗号后面的是毫秒。 %(msecs)d：%(asctime)s 的毫秒部分。 %(relativeCreated)d：自 Logger 创建以来的毫秒数。 %(thread)d：线程 ID。 %(threadName)s：线程名称。 %(process)d：进程 ID。 %(processName)s：进程名称。 %(message)s：日志信息。
detefmt	指定日期/时间的输出格式，与 time.strftime()所接受的格式相同。
style	Python 3.2 版本新增参数。指定 format 格式字符串的风格。“%”，“{”或“$”分别对应于 printf-style，str.format()或 string.Template。默认为“%”。
level	指定日志级别。
stream	指定数据流初始化`StreamHandler`，例如：`sys.stderr`、`sys.stdout`或任何`file-like`对象，默认为`sys.stderr`。注意此参数与 filename 不兼容，如果两者同时存在，则会引发`ValueError`。
handlers	Python 3.3 版本新增参数。指定日志处理时所使用的 Handler，必须是可迭代的对象。注意此参数与 filename 或 stream 不兼容，如果两者同时存在，则会引发`ValueError`。
force	Python 3.8 版本新增参数。指定是否删除其它 Handler。
encoding	Python 3.9 版本新增参数。指定日志输出文件的编码格式。
errors	Python 3.9 版本新增参数。指定编码格式错误的处理方式，默认为“backslashreplace”。

示例：

import logging
import sys


def basic_config():
    # 日志信息的输出格式
    fmt = '%(name)s-%(levelno)s-%(levelname)s-%(pathname)s-%(filename)s-%(module)s-%(lineno)d-%(funcName)s-%(created)f-%(asctime)s-%(msecs)d-%(relativeCreated)d-%(thread)d-%(threadName)s-%(process)d-%(processName)s-%(message)s'
    # 将日志输出到控制台 StreamHandler
    stream_handler = logging.StreamHandler(sys.stdout)
    # 将日志输出到文件 FileHandler
    file_handler = logging.FileHandler('all.log', mode='w', encoding='utf-8')
    # 日志配置
    logging.basicConfig(format=fmt, datefmt='%Y/%m/%d %H:%M:%S', level='INFO', handlers=[stream_handler, file_handler])
    # force 默认为 False，配置信息以上一条为准，force=True 时，配置信息以下面这条为准
    logging.basicConfig(format=fmt, datefmt='%Y/%m/%d %H:%M:%S', level='ERROR', handlers=[stream_handler, file_handler], force=True)
    # 日志信息
    logging.critical('严重错误...')
    logging.error('错误...')
    logging.warning('警告...')
    logging.info('关键信息...')
    logging.debug('详细信息...')


if __name__ == '__main__':
    basic_config()

运行结果：

D:\Python39\python.exe D:/JetBrains/PycharmProjects/python-logging/basicConfig_demo.py
root-50-CRITICAL-D:\JetBrains\PycharmProjects\python-logging\basicConfig_demo.py-basicConfig_demo.py-basicConfig_demo-19-basic_config-1693216745.661029-2023/08/28 17:59:05-661-217-3152-MainThread-18872-MainProcess-严重错误...
root-40-ERROR-D:\JetBrains\PycharmProjects\python-logging\basicConfig_demo.py-basicConfig_demo.py-basicConfig_demo-20-basic_config-1693216745.661029-2023/08/28 17:59:05-661-217-3152-MainThread-18872-MainProcess-错误...

Process finished with exit code 0

三、logging 模块的四种对象

对象	描述
Logger	日志生成器，产生日志的对象。1 个 Logger 对象可以绑定多个 Handler，用以输出至不同位置。
Filter	日志过滤器，过滤日志的对象。
Handler	日志处理器，处理日志的对象。对日志进行格式化，并输出到指定位置。
Formatter	处理日志的格式。

一条日志完整的生命周期：
1.由 Logger 产生日志 -> 2.交给过滤器判断是否被过滤 -> 3.将日志消息分发给绑定的所有处理器 -> 4.处理器按照绑定的格式化对象输出日志

3.1 Logger 对象相关方法

方法	描述
Logger.setLevel()	指定日志级别。
Logger.addFilter()	为 Logger 对象添加一个 Filter 对象。
Logger.removeFilter()	为 Logger 对象移除一个 Filter 对象。
Logger.addHandler()	为 Logger 对象添加一个 Handler 对象。
Logger.removeHandler()	为 Logger 对象移除一个 Handler 对象。
Logger.critical()	创建一条 CRITICAL 级别的日志。
Logger.error()	创建一条 ERROR 级别的日志。
Logger.warning()	创建一条 WARNING 级别的日志。
Logger.info()	创建一条 INFO 级别的日志。
Logger.debug()	创建一条 DEBUG 级别的日志。
Logger.exception()	创建一条类似 ERROR 级别的日志。
Logger.log()	创建一条指定级别的日志。

3.2 Handler 对象相关方法

方法	描述
Handler.setLevel()	指定日志级别。
Handler.setFormatter()	为 Handler 对象设置一个 Formatter 对象。
Handler.addFilter()	为 Handler 对象添加一个 Filter 对象。
Handler.removeFilter()	为 Handler 对象移除一个 Filter 对象。

3.3 Handler 对象相关子类

子类	描述
logging.StreamHandler	将日志输出到数据流，例如：`sys.stderr`、`sys.stdout`或任何`file-like`对象，默认为`sys.stderr`。
logging.FileHandler	将日志输出到文件。
logging.NullHandler	不执行任何格式化或输出，它实际上是一个供库开发者使用的“无操作”处理程序。
logging.handlers.RotatingFileHandler	日志按指定的文件大小轮换。
logging.handlers.TimedRotatingFileHandler	日志按指定的时间间隔轮换。
logging.handlers.SocketHandler	将日志输出到网络套接字。基类所使用的是 TCP 套接字。
logging.handlers.DatagramHandler	它继承自`SocketHandler`，将日志输出到网络套接字。基类所使用的是 UDP 套接字。
logging.handlers.SMTPHandler	将日志发送到邮箱。
logging.handlers.SysLogHandler	将日志发送到远程或本地 Unix syslog。
logging.handlers.MemoryHandler	在内存中缓冲日志，并定期将其刷新到 target 处理程序中。刷新会在缓冲区满的时候，或是在遇到特定或更高严重程度事件的时候发生。
logging.handlers.HTTPHandler	使用`GET`或`POST`将日志发送到 Web 服务器。

示例：

import logging
import sys


# 自定义过滤器并设置过滤条件
class CustomFilter(logging.Filter):
    # 忽略包含 test 的日志
    def filter(self, record) -> bool:
        # print(record.getMessage())
        return 'test' not in record.getMessage()


def stream_and_file_handler():
    # 创建日志生成器 Logger
    logger = logging.getLogger('logger')
    # 设置 Logger 对象日志级别
    logger.setLevel(level='DEBUG')
    # 创建日志处理器 StreamHandler 将日志输出到控制台
    stream_handler = logging.StreamHandler(sys.stdout)
    # 创建日志处理器 FileHandler 将日志输出到文件
    file_handler = logging.FileHandler('all.log', mode='w', encoding='utf-8')
    # 设置 Handler 对象日志级别。Handler 对象日志级别应高于 Logger 对象日志级别，否则，设置 Handler 对象日志级别是没有意义的。
    stream_handler.setLevel(level='INFO')
    file_handler.setLevel(level='INFO')
    # 实例化过滤器 Filter
    custom_filter = CustomFilter()
    # 将过滤器添加到处理器
    stream_handler.addFilter(custom_filter)
    file_handler.addFilter(custom_filter)
    # 创建日志格式器 Formatter
    stream_fmt = logging.Formatter(fmt='%(asctime)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(message)s')
    file_fmt = logging.Formatter(fmt='%(asctime)s-%(name)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(process)d-%(processName)s-%(thread)d-%(threadName)s-%(message)s')
    # 设置处理器的日志格式
    stream_handler.setFormatter(stream_fmt)
    file_handler.setFormatter(file_fmt)
    # 将处理器添加到 Logger 对象
    logger.addHandler(stream_handler)
    logger.addHandler(file_handler)
    # 输出日志
    logger.critical('严重错误...')
    logger.error('错误...')
    logger.warning('警告...')
    logger.info('关键信息...')
    logger.debug('详细信息...')
    logger.info('test message...')
    logger.info('This is a test message...')


if __name__ == '__main__':
    stream_and_file_handler()

运行结果：

D:\Python39\python.exe D:/JetBrains/PycharmProjects/python-logging/logging_demo.py
2023-08-29 18:27:58,921-CRITICAL-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-stream_and_file_handler-40-严重错误...
2023-08-29 18:27:58,921-ERROR-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-stream_and_file_handler-41-错误...
2023-08-29 18:27:58,921-WARNING-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-stream_and_file_handler-42-警告...
2023-08-29 18:27:58,921-INFO-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-stream_and_file_handler-43-关键信息...

Process finished with exit code 0

四、日志轮换

4.1 日志按指定的文件大小轮换

logging.handlers.RotatingFileHandler(filename, mode=‘a’, maxBytes=0, backupCount=0, encoding=None, delay=False, errors=None)

参数	描述
filename	指定输出日志的文件名。Python 3.6 以及之后版本除了字符串值，也接受 Path 对象作为 filename 参数。
mode	指定文件打开模式，默认模式为“a”。
maxBytes	指定文件大小，单位为字节。当即将超出指定大小时，将关闭旧文件并打开一个新文件用于输出。
backupCount	指定备份文件数量，多了就会把最旧的那个文件删除。注意如果 maxBytes 或 backupCount 两者之一的值为零，就不会发生轮换。
encoding	指定日志输出文件的编码格式。
delay	如果 delay 为 True，则文件打开会被推迟至第一次调用`emit()`的时候。默认情况下，文件会无限增长。
errors	Python 3.9 版本新增参数。指定编码格式错误的处理方式。

4.2 日志按指定的时间间隔轮换

logging.handlers.TimedRotatingFileHandler(filename, when=‘h’, interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None, errors=None)

参数	描述
filename	指定输出日志的文件名。Python 3.6 以及之后版本除了字符串值，也接受 Path 对象作为 filename 参数。
when	指定 interval 的类型。
interval	指定间隔时间。
backupCount	指定备份文件数量，多了就会把最旧的那个文件删除。
encoding	指定日志输出文件的编码格式。
delay	如果 delay 为 True，则文件打开会被推迟至第一次调用`emit()`的时候。
utc	如果 utc 为 True，将使用 UTC 时间；否则会使用本地时间。
atTime	Python 3.4 版本新增参数。如果 atTime 不为`None`，则它必须是一个`datetime.time`的实例，该实例指定轮换在一天内的发生时间，用于轮换被设为“midnight”或“W0-W6”之类的情况。请注意在这些情况下，atTime 值实际上会被用于计算初始轮换，而后续轮换将会通过正常的间隔时间计算来得出。
errors	Python 3.9 版本新增参数。指定编码格式错误的处理方式。

使用 when 来指定 interval 的类型。

值	间隔类型	如何使用 atTime
‘S’	秒	忽略
‘M’	分钟	忽略
‘H’	小时	忽略
‘D’	天	忽略
‘W0’-‘W6’	工作日(0=星期一)	用于计算初始轮换时间
‘midnight’	如果未指定 atTime 则在午夜执行轮换，否则将使用 atTime。	用于计算初始轮换时间

当使用基于星期的轮换时，星期一为’W0’，星期二为’W1’，以此类推直至星期日为’W6’。在这种情况下，传入的 interval 值不会被使用。

4.3 示例

import logging
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
import datetime


def logger_configure(*args,
                     level='INFO',
                     fmt='%(asctime)s-%(name)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(process)d-%(processName)s-%(thread)d-%(threadName)s-%(message)s',
                     force=True):

    logging.basicConfig(
        handlers=list(args),
        level=level,
        format=fmt,
        force=force
    )


if __name__ == '__main__':
    # 创建按指定的文件大小轮换的日志处理器 RotatingFileHandler
    rotating_file_handler = RotatingFileHandler('logs/all.log', maxBytes=1024*1024*10, backupCount=10, encoding='utf-8')
    # 创建按指定的时间间隔轮换的日志处理器 TimedRotatingFileHandler
    timed_rotating_file_handler = TimedRotatingFileHandler('logs/error.log', when='midnight', interval=1, backupCount=7, encoding='utf-8', atTime=datetime.time(0, 0, 0, 0))
    logger_configure(rotating_file_handler, timed_rotating_file_handler)
    for i in range(10):
        logging.info('info level:{}'.format(i))

五、日志回溯

logging 模块支持记录回溯信息，可以使用 exc_info 参数来记录当前异常的回溯信息。回溯信息包含了程序执行时的堆栈信息，即函数调用栈的跟踪信息。回溯信息可以帮助开发人员定位程序错误的根源。可以使用 Logger 对象的error()、exception()或critical()方法来记录异常信息和回溯信息。
示例：

import logging

if __name__ == '__main__':
    logger = logging.getLogger('logger')
    logger.setLevel(level='DEBUG')
    try:
        # 0 不能当被除数
        result = 1 / 0
    except Exception as e:
        # exc_info 参数默认为"False"，仅打印异常信息：division by zero；将 exc_info 参数设置为 True，就会打印完整的异常信息和回溯信息。
        logger.error(e, exc_info=True)

上例中，exc_info 参数默认为 False，仅打印异常信息：

division by zero

现在将 exc_info 参数设置为 True，就会打印完整的异常信息和回溯信息：

division by zero
Traceback (most recent call last):
  File "D:\JetBrains\PycharmProjects\python-logging\logging_demo.py", line 8, in <module>
    result = 1 / 0
ZeroDivisionError: division by zero

六、日志继承

logging 模块支持将一个日志指定为另一个日志的子级日志，当存在继承关系时，子级日志收到的日志会将该日志向上传递。
示例：

import logging

if __name__ == '__main__':
    # 创建日志生成器 Logger，当存在继承关系时，子级日志收到的日志会将该日志向上传递。
    log1 = logging.getLogger('father')
    log2 = logging.getLogger('father.son')
    log3 = logging.getLogger('father.son.grandson')
    # 创建日志处理器 FileHandler 将日志输出到文件
    handler = logging.FileHandler('all.log', mode='w', encoding='utf-8')
    # 创建日志格式器 Formatter
    fmt = logging.Formatter(fmt='%(asctime)s-%(name)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(process)d-%(processName)s-%(thread)d-%(threadName)s-%(message)s')
    # 设置处理器的日志格式
    handler.setFormatter(fmt)
    # 将处理器添加到 Logger 对象
    log1.addHandler(handler)
    log2.addHandler(handler)
    log3.addHandler(handler)
    # 输出日志
    # log1.error('------错误------')
    # log2.error('------错误------')
    log3.error('------错误------')
    # 取消传递
    log3.propagate = False
    # 再次输出日志
    log3.error('++++++错误++++++')

输出日志信息：

2023-08-30 19:46:44,289-father.son.grandson-ERROR-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-<module>-21-20404-MainProcess-18760-MainThread-------错误------
2023-08-30 19:46:44,289-father.son.grandson-ERROR-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-<module>-21-20404-MainProcess-18760-MainThread-------错误------
2023-08-30 19:46:44,289-father.son.grandson-ERROR-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-<module>-21-20404-MainProcess-18760-MainThread-------错误------
2023-08-30 19:46:44,289-father.son.grandson-ERROR-D:\JetBrains\PycharmProjects\python-logging\logging_demo.py-<module>-25-20404-MainProcess-18760-MainThread-++++++错误++++++

七、通过配置字典定义日志

通常我们会使用一个配置字典来定义日志。
示例：

导入 logging 模块。

import logging
import os
import sys
import datetime
from logging import config

定义两种日志输出格式。

# 定义两种日志输出格式
standard_format = '%(asctime)s-%(name)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(process)d-%(processName)s-%(thread)d-%(threadName)s-%(message)s'
simple_format = '%(asctime)s-%(levelname)s-%(pathname)s-%(funcName)s-%(lineno)d-%(message)s'

定义日志文件路径。

# 定义日志文件所在目录
logfile_dir = os.path.join(os.path.abspath(os.pardir), 'logs')

# 定义日志文件名
logfile_all_name = 'all.log'
logfile_error_name = 'error.log'

# 如果定义的日志文件所在目录不存在就创建一个
if not os.path.exists(logfile_dir):
    os.mkdir(logfile_dir)

# 日志文件完整路径
logfile_all_path = os.path.join(logfile_dir, logfile_all_name)
logfile_error_path = os.path.join(logfile_dir, logfile_error_name)

配置字典。通常会放在配置文件中，比如项目 conf 目录下 settings 文件中。

# 配置字典
LOGGING_DIC = {
    
    
    'version': 1,  # 配置字典的版本
    'disable_existing_loggers': False,  # 是否关闭已存在的日志，默认为 False
    'formatters': {
    
      # 日志格式，里面定义的是多个 Formatter 对象
        'standard': {
    
      # 上述定义的 standard_format 格式
            'format': standard_format
        },
        'simple': {
    
      # 上述定义的 simple_format 格式
            'format': simple_format
        }
    },
    'filter': {
    
    },  # 日志过滤器，不常用
    'handlers': {
    
      # 日志处理器，里面定义的是多个 Handler 对象
        'console': {
    
      # 将日志打印到控制台
            'level': 'DEBUG',  # 设置日志级别为 DEBUG
            'class': 'logging.StreamHandler',  # 将日志打印到控制台的 Handler 对象 StreamHandler
            'stream': sys.stdout,  # 将日志输出到数据流
            'formatter': 'simple'  # 绑定 Formatter 对象 simple
        },
        # 'all': {  # 日志按指定的文件大小轮换
        #     'level': 'DEBUG',  # 设置日志级别为 DEBUG
        #     'class': 'logging.handlers.RotatingFileHandler',  # 日志按指定的文件大小轮换的 Handler 对象 RotatingFileHandler
        #     'formatter': 'standard',  # 绑定 Formatter 对象 standard
        #     'filename': logfile_all_path,  # 指定日志文件路径
        #     'mode': 'a',  # 指定文件打开模式，默认模式为 a（追加写入）。
        #     'maxBytes': 1024*1024*10,  # 指定文件大小，单位为字节。当即将超出指定大小时，将关闭旧文件并打开一个新文件用于输出。
        #     'backupCount': 10,  # 最多保存 10 个文件，多了就会把最旧的那个文件删除。
        #     'encoding': 'utf-8'  # 指定日志输出文件的编码格式，通常指定为 utf-8。
        # },
        # 'error': {  # 日志按指定的文件大小轮换
        #     'level': 'ERROR',  # 设置日志级别为 ERROR
        #     'class': 'logging.handlers.RotatingFileHandler',  # 日志按指定的文件大小轮换的 Handler 对象 RotatingFileHandler
        #     'formatter': 'standard',  # 绑定 Formatter 对象 standard
        #     'filename': logfile_error_path,  # 指定日志文件路径
        #     'mode': 'a',  # 指定文件打开模式，默认模式为 a（追加写入）。
        #     'maxBytes': 1024*1024*10,  # 指定文件大小，单位为字节。当即将超出指定大小时，将关闭旧文件并打开一个新文件用于输出。
        #     'backupCount': 10,  # 最多保存 10 个文件，多了就会把最旧的那个文件删除。
        #     'encoding': 'utf-8'  # 指定日志输出文件的编码格式，通常指定为 utf-8。
        # },
        'all': {
    
      # 日志按指定的时间间隔轮换
            'level': 'DEBUG',  # 设置日志级别为 DEBUG
            'class': 'logging.handlers.TimedRotatingFileHandler',  # 日志按指定的时间间隔轮换的 Handler 对象 TimedRotatingFileHandler
            'formatter': 'standard',  # 绑定 Formatter 对象 standard
            'filename': logfile_all_path,  # 指定日志文件路径
            'when': 'midnight',  # 指定 interval 的类型，可选参数：S(秒),M(分钟),H(小时),D(天),midnight(午夜),W0-W6(工作日，0=星期一)
            'interval': 1,  # 指定间隔时间
            'atTime': datetime.time(0, 0, 0, 0),  # 指定初始轮换时间
            'backupCount': 7,  # 最多保存 7 个文件，多了就会把最旧的那个文件删除。
            'encoding': 'utf-8'  # 指定日志输出文件的编码格式，通常指定为 utf-8。
        },
        'error': {
    
      # 日志按指定的时间间隔轮换
            'level': 'ERROR',  # 设置日志级别为 ERROR
            'class': 'logging.handlers.TimedRotatingFileHandler',  # 日志按指定的时间间隔轮换的 Handler 对象 TimedRotatingFileHandler
            'formatter': 'standard',  # 绑定 Formatter 对象 standard
            'filename': logfile_error_path,  # 指定日志文件路径
            'when': 'midnight',  # 指定 interval 的类型，可选参数：S(秒),M(分钟),H(小时),D(天),midnight(午夜),W0-W6(工作日，0=星期一)
            'interval': 1,  # 指定间隔时间
            'atTime': datetime.time(0, 0, 0, 0),  # 指定初始轮换时间
            'backupCount': 7,  # 最多保存 7 个文件，多了就会把最旧的那个文件删除
            'encoding': 'utf-8'  # 指定日志输出文件的编码格式，通常指定为 utf-8。
        }
    },
    'loggers': {
    
      # 日志生成器，里面定义的是多个 Logger 对象
        '': {
    
      # logging.getLogger(name)，name 就是字典中 loggers 的 key，如果没有匹配的 key，就返回默认的生成器，通过在字典中设置空的 key 设置默认的生成器。
            'level': 'DEBUG',  # 设置日志级别为 DEBUG
            'handlers': ['console', 'all', 'error'],  # 这里将上面定义的 Handler 都加上，即输出到控制台同时保存到文件。
            'propagate': False  # 向上（父级logger）传递，通常设置为 False，否则一份日志会层层向上传递。
        }
    }
}

其它文件使用配置字典需要先导入配置文件。

import logging
from logging import config
from conf import settings

加载配置。

config.dictConfig(settings.LOGGING_DIC)

创建日志生成器 Logger，输出日志。

logger = logging.getLogger('logger')
for i in range(10):
    logger.info('info level:{}'.format(i))
    logger.error('error level:{}'.format(i))