python如何做日志程序

要在Python中创建一个日志程序，可以使用Python标准库中的logging模块。Python的logging模块提供了灵活的记录日志的功能、可以方便地记录不同级别的日志、可以配置日志输出的格式和目标。下面我们详细介绍如何使用logging模块来创建一个功能完善的日志程序。

一、安装和导入logging模块

logging模块是Python标准库的一部分，因此无需额外安装。只需在代码中导入即可：

import logging

二、基本配置

使用logging模块记录日志的最简单方法是使用basicConfig函数来配置日志系统。这包括设置日志级别、日志格式和日志输出目标等。例如：

import logging
logging.basicConfig(level=logging.DEBUG, 
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', 
                    datefmt='%Y-%m-%d %H:%M:%S',
                    handlers=[logging.FileHandler("app.log"), logging.StreamHandler()])
logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')

在上面的代码中，我们使用了basicConfig函数来设置日志记录的配置：

level参数设置日志级别为DEBUG，表示记录所有级别的日志信息。
format参数设置日志的输出格式，包括时间、日志器名称、日志级别和日志消息。
datefmt参数设置时间格式。
handlers参数设置日志输出目标，包括文件和控制台。

三、日志级别

logging模块提供了多个日志级别，用于表示日志的严重程度。日志级别从低到高依次为：

DEBUG：详细的信息，通常只在诊断问题时使用。
INFO：确认程序按预期工作的信息。
WARNING：表示可能出现问题的警告信息。
ERROR：由于更严重的问题，程序已不能执行某些功能。
CRITICAL：严重错误，表示程序可能无法继续运行。

四、创建日志器

在实际开发中，我们通常会为每个模块或类创建一个单独的日志器，以便更好地管理日志。可以使用logging.getLogger函数创建日志器。例如：

import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
创建文件处理器
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.addHandler(console_handler)
logger.addHandler(file_handler)
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

在上面的代码中，我们：

使用logging.getLogger函数创建了一个日志器对象。
创建了两个处理器，分别用于将日志输出到控制台和文件。
创建了一个格式器，并将其添加到处理器。
将处理器添加到日志器。

五、日志的高级配置

在实际应用中，可能需要更复杂的日志配置，例如为不同模块设置不同的日志级别，为不同的处理器设置不同的格式等。可以使用配置文件或字典进行配置。

1、使用配置文件

可以将日志配置写入配置文件，并在代码中加载配置文件。例如：

# logging.conf
[loggers]
keys=root,sampleLogger
[handlers]
keys=consoleHandler,fileHandler
[formatters]
keys=sampleFormatter
[logger_root]
level=DEBUG
handlers=consoleHandler
[logger_sampleLogger]
level=DEBUG
handlers=consoleHandler,fileHandler
qualname=sampleLogger
propagate=0
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=sampleFormatter
args=(sys.stdout,)
[handler_fileHandler]
class=FileHandler
level=DEBUG
formatter=sampleFormatter
args=('app.log', 'a')
[formatter_sampleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=%Y-%m-%d %H:%M:%S

然后在代码中加载配置文件：

import logging
import logging.config
logging.config.fileConfig('logging.conf')
logger = logging.getLogger('sampleLogger')
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

2、使用字典配置

也可以使用字典配置日志系统。例如：

import logging
import logging.config
log_config = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'default': {
            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S',
        },
    },
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'level': 'DEBUG',
            'formatter': 'default',
        },
        'file': {
            'class': 'logging.FileHandler',
            'level': 'DEBUG',
            'formatter': 'default',
            'filename': 'app.log',
        },
    },
    'loggers': {
        '': {
            'level': 'DEBUG',
            'handlers': ['console', 'file'],
        },
    },
}
logging.config.dictConfig(log_config)
logger = logging.getLogger(__name__)
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

六、捕获异常日志

在开发过程中，捕获和记录异常信息是非常重要的。可以使用logging模块的exception方法记录异常信息。例如：

import logging
logger = logging.getLogger(__name__)
try:
    1 / 0
except ZeroDivisionError:
    logger.exception('An exception occurred')

logger.exception方法会自动记录异常的堆栈信息，非常适合在捕获异常时使用。

七、多进程和多线程日志

在多进程和多线程环境中，日志的处理稍微复杂一些。可以使用logging模块的QueueHandler和QueueListener来处理多进程和多线程日志。

1、多进程日志

在多进程环境中，可以使用QueueHandler和QueueListener来安全地记录日志。例如：

import logging
import logging.handlers
import multiprocessing
def logger_process(queue):
    root = logging.getLogger()
    h = logging.handlers.QueueHandler(queue)
    root.addHandler(h)
    root.setLevel(logging.DEBUG)
    listener = logging.handlers.QueueListener(queue, *root.handlers)
    listener.start()
    try:
        logger = logging.getLogger('logger_process')
        logger.info('Logger process started')
        while True:
            pass
    finally:
        listener.stop()
def worker_process(queue, worker_id):
    h = logging.handlers.QueueHandler(queue)
    root = logging.getLogger()
    root.addHandler(h)
    root.setLevel(logging.DEBUG)
    logger = logging.getLogger(f'worker_{worker_id}')
    logger.info(f'Worker {worker_id} started')
if __name__ == '__main__':
    queue = multiprocessing.Queue(-1)
    logger_p = multiprocessing.Process(target=logger_process, args=(queue,))
    logger_p.start()
    workers = [multiprocessing.Process(target=worker_process, args=(queue, i)) for i in range(4)]
    for w in workers:
        w.start()
    for w in workers:
        w.join()
    logger_p.terminate()

在上面的代码中，logger_process函数负责启动日志记录进程，worker_process函数负责工作进程。日志记录进程使用QueueListener来监听日志消息队列，工作进程使用QueueHandler将日志消息发送到消息队列。

2、多线程日志

在多线程环境中，可以使用QueueHandler和QueueListener来安全地记录日志。例如：

import logging
import logging.handlers
import threading
import queue
def logger_thread(log_queue):
    root = logging.getLogger()
    h = logging.handlers.QueueHandler(log_queue)
    root.addHandler(h)
    root.setLevel(logging.DEBUG)
    listener = logging.handlers.QueueListener(log_queue, *root.handlers)
    listener.start()
    try:
        logger = logging.getLogger('logger_thread')
        logger.info('Logger thread started')
        while True:
            pass
    finally:
        listener.stop()
def worker_thread(log_queue, worker_id):
    h = logging.handlers.QueueHandler(log_queue)
    root = logging.getLogger()
    root.addHandler(h)
    root.setLevel(logging.DEBUG)
    logger = logging.getLogger(f'worker_{worker_id}')
    logger.info(f'Worker {worker_id} started')
if __name__ == '__main__':
    log_queue = queue.Queue(-1)
    logger_t = threading.Thread(target=logger_thread, args=(log_queue,))
    logger_t.start()
    workers = [threading.Thread(target=worker_thread, args=(log_queue, i)) for i in range(4)]
    for w in workers:
        w.start()
    for w in workers:
        w.join()
    logger_t.join()

在上面的代码中，logger_thread函数负责启动日志记录线程，worker_thread函数负责工作线程。日志记录线程使用QueueListener来监听日志消息队列，工作线程使用QueueHandler将日志消息发送到消息队列。

八、总结

通过以上内容，我们详细介绍了Python中如何使用logging模块创建一个功能完善的日志程序。Python的logging模块非常灵活和强大，能够满足大多数日志记录的需求。在实际开发中，可以根据具体需求进行配置和扩展，以实现更复杂的日志功能。通过合理地记录日志，可以帮助我们更好地诊断和调试问题，提高程序的稳定性和可维护性。