python内置模块之Log日志模块

Log日志模块

前言

 logging 是python中的一个包，封装所有日志功能。

例如获取日志器 logging.getLogger 是logging包的 __init__ 文件中定义的函数（包的 __init__文件中的函数直接可以使用包名.函数名调用），如下 getLogger 代码：

def getLogger(name=None):
    """
    Return a logger with the specified name, creating it if necessary.

    If no name is specified, return the root logger.
    """
    if not name or isinstance(name, str) and name == root.name:
        return root
    return Logger.manager.getLogger(name)

root = RootLogger(WARNING)

class RootLogger(Logger):
    """
    A root logger is not that different to any other logger, except that
    it must have a logging level and there is only one instance of it in
    the hierarchy.
    """
    def __init__(self, level):
        """
        Initialize the logger with the name "root".
        """
        Logger.__init__(self, "root", level)

    def __reduce__(self):
        return getLogger, ()

即 getLogger 函数返回值为Logger类的实例对象。

例如为日志器设置默认的日志级别 logger.setLevel() 为logging包的 __init__ 文件 Logger 类中的 setLevel 函数，代码如下：

    def setLevel(self, level):
        """
        Set the logging level of this logger.  level must be an int or a str.
        """
        self.level = _checkLevel(level)
        self.manager._clear_cache()

def _checkLevel(level):
    if isinstance(level, int):
        rv = level
    elif str(level) == level:
        if level not in _nameToLevel:
            raise ValueError("Unknown level: %r" % level)
        rv = _nameToLevel[level]
    else:
        raise TypeError("Level not an integer or a valid string: %r" % level)
    return rv

_nameToLevel = {
    'CRITICAL': CRITICAL,
    'FATAL': FATAL,
    'ERROR': ERROR,
    'WARN': WARNING,
    'WARNING': WARNING,
    'INFO': INFO,
    'DEBUG': DEBUG,
    'NOTSET': NOTSET,
}

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

一、logging函数根据它们用来跟踪的事件的级别或严重程度来命名。标准级别及其适用性描述如下（以严重程度递增排序）：

 

默认等级是WARNING，只有高于默认等级以上的级别才会打印到控制台。

①将日志直接输出到屏幕

"""
由于默认设置的等级是warning，所有只有warning的信息会输出到控制台。
"""

import logging

logging.debug('debug 信息')
logging.warning('只有这个会输出。。。')
logging.info('info 信息')

输出结果：

 

②通过logging.basicConfig函数对日志的输出格式及方式做相关配置 

import logging

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')
    
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')


#./myapp.log文件中内容为:
#Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
#Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
#Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

logging.basicConfig参数：

#logging.basicConfig函数各参数:

filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
    %(levelno)s:     打印日志级别的数值
    %(levelname)s:     打印日志级别名称
    %(pathname)s:     打印当前执行程序的路径，其实就是sys.argv[0]
    %(filename)s:     打印当前执行程序名
    %(funcName)s:     打印日志的当前函数
    %(lineno)d:     打印日志的当前行号
    %(asctime)s:     打印日志的时间
    %(thread)d:     打印线程ID
    %(threadName)s: 打印线程名称
    %(process)d:     打印进程ID
    %(message)s:     打印日志信息
datefmt:     指定时间格式，同time.strftime()
level:         设置日志级别，默认为logging.WARNING【高于该日志级别才会打印到控制台上】
stream:     指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略

 

③将日志同时输出到多个Handler

定义handler，并使用addHander()添加到日志器，实现日志输出到多个handler。

a、同时输出到文件和屏幕

import logging
#设置一个basicConfig只能输出到一个Handler
logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')

#定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)

#输出到文件的log级别为debug，输出到stream的log级别为info
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')

b、添加一个handler：输出到文件，并根据文件大小滚动存储

在a的基础上添加一个handler

from logging.handlers import RotatingFileHandler
#定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M
Rthandler = RotatingFileHandler('myapp.log', maxBytes=10*1024*1024,backupCount=5)
Rthandler.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
Rthandler.setFormatter(formatter)
logging.getLogger('').addHandler(Rthandler)

logging几种Handler类型：

logging.StreamHandler(默认):     日志输出到流，可以是sys.stderr、sys.stdout或者文件
logging.FileHandler:             日志输出到文件
logging.handlers.RotatingFileHandler    日志输出到文件，基于文件大小滚动存储日志
logging.handlers.TimedRotatingFileHandler    日志输出到文件，基于时间周期滚动存储日志
logging.handlers.SocketHandler:     远程输出日志到TCP/IP sockets
logging.handlers.DatagramHandler:      远程输出日志到UDP sockets
logging.handlers.SMTPHandler:          远程输出日志到邮件地址
logging.handlers.SysLogHandler:     日志输出到syslog
logging.handlers.NTEventLogHandler: 远程输出日志到Windows NT/2000/XP的事件日志
logging.handlers.MemoryHandler:     日志输出到内存中的制定buffer
logging.handlers.HTTPHandler:         通过"GET"或"POST"远程输出到HTTP服务器

 

④通过配置文件配置logger

a、定义配置文件 logger.conf 

#logger.conf
###############################################
[loggers]
keys=root,example01,example02
[logger_root]
level=DEBUG
handlers=hand01,hand02
[logger_example01]
handlers=hand01,hand02
qualname=example01
propagate=0
[logger_example02]
handlers=hand01,hand03
qualname=example02
propagate=0
###############################################

[handlers]
keys=hand01,hand02,hand03
[handler_hand01]
class=StreamHandler
level=INFO
formatter=form02
args=(sys.stderr,)
[handler_hand02]
class=FileHandler
level=DEBUG
formatter=form01
args=('myapp.log', 'a')
[handler_hand03]
class=handlers.RotatingFileHandler
level=INFO
formatter=form02
args=('myapp.log', 'a', 10*1024*1024, 5)
###############################################
[formatters]
keys=form01,form02
[formatter_form01]
format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s
datefmt=%a, %d %b %Y %H:%M:%S
[formatter_form02]
format=%(name)-12s: %(levelname)-8s %(message)s
datefmt=

b、 logging.config 获取配置

import logging
import logging.config

logging.config.fileConfig("logger.conf")
logger = logging.getLogger("example01")

logger.debug('This is debug message')
logger.info('This is info message')
logger.warning('This is warning message')

import logging
import logging.config

logging.config.fileConfig("logger.conf")
logger = logging.getLogger("example02")

logger.debug('This is debug message')
logger.info('This is info message')
logger.warning('This is warning message')

二、logging库【python中已封装好的功能模块】采取了模块化的设计，

提供了许多组件：记录器（日志器logger）、处理器（handles）、过滤器和格式化器（formatters）。

1、Logger 暴露了应用程序代码能直接使用的接口。

2、Handler将（记录器产生的）日志记录发送至合适的目的地。

3、Filter提供了更好的粒度控制，它可以决定输出哪些日志记录。

4、Formatter 指明了最终输出中日志记录的布局。

三、Loggers

Logger 对象要做三件事情。

首先，它们向应用代码暴露了许多方法，这样应用可以在运行时记录消息。

其次，记录器对象通过严重程度（默认的过滤设施）或者过滤器对象来决定哪些日志消息需要记录下来。

第三，记录器对象将相关的日志消息传递给所有感兴趣的日志处理器。

常用的记录器对象的方法分为两类：配置和发送消息。

这些是最常用的配置方法：

①Logger.setLevel()指定logger将会处理的最低的安全等级日志信息：
debug是最低的内置安全等级；
critical是最高的内置安全等级。
例如，如果严重程度为INFO，记录器将只处理INFO，WARNING，ERROR和CRITICAL消息，DEBUG消息被忽略。

②Logger.addHandler()和Logger.removeHandler()从记录器对象中添加和删除处理程序对象。处理器详见Handlers。

③Logger.addFilter()和Logger.removeFilter()从记录器对象添加和删除过滤器对象。

四、Handlers

处理程序对象负责将适当的日志消息（基于日志消息的严重性）分派到处理程序的指定目标。【根据分配到的Handlers不同，又将不同的日志信息以不同的方式输出】

Logger 对象可以通过addHandler()方法增加零个或多个handler对象。

举个例子：①一个应用可以将所有的日志消息发送至日志文件；②所有的错误级别（error）及以上级别的日志消息发送至标准输出；③所有的严重级别（critical）日志消息发送至某个电子邮箱。
在这个例子中需要三个独立的处理器，每一个负责将特定级别的日志消息发送至特定的位置。

常用的有4种：

1、 logging.StreamHandler ： 控制台输出

向类似与 sys.stdout 或者 sys.stderr 的任何文件对象(file object)输出信息。

它的构造函数是： StreamHandler([strm]) 

参数介绍：strm参数是一个文件对象。默认是sys.stderr（不传strm参数时，默认将日志信息输出至控制台）。

2、 logging.FileHandler  ： 文件输出

用于向一个文件输出日志信息。

构造函数是： FileHandler(filename[,mode]) 

参数介绍：①filename文件名：必须指定一个文件名；②mode是文件的打开方式。默认是’a'，即添加到文件末尾。

3、logging.handlers.RotatingFileHandler ： 按照大小自动分割日志文件，一旦达到指定的大小重新生成文件

这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建一个新的同名日志文件继续输出。

例子：比如日志文件是chat.log。
当chat.log达到指定的大小之后，RotatingFileHandler自动把文件改名为chat.log.1。
不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。

构造函数： RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]]) 

参数介绍：①filename文件名：必须指定一个文件名。②mode是文件的打开方式。默认是’a'，即添加到文件末尾。③maxBytes用于指定日志文件的最大文件大小。【如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。】。④backupCount用于指定保留的备份文件的个数。【如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。】

4、 logging.handlers.TimedRotatingFileHandler ：按照时间自动分割日志文件

这个Handler和RotatingFileHandler类似；
不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。
重命名的过程与RotatingFileHandler类似：不过新的文件不是附加数字，而是当前时间。

构造函数： TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]]) 

参数介绍：

①filename文件名：必须指定一个文件名。

②mode是文件的打开方式。默认是’a'，即添加到文件末尾。③backupCount用于指定保留的备份文件的个数。

④interval是时间间隔。

⑤when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：

S 秒

M 分

H 小时

D 天

W 每星期（interval==0时代表星期一）

midnight 每天凌晨

配置方法：

① handlers.setLevel() ：记录器的级别决定了消息是否要传递给处理器。每个处理器的级别决定了消息是否要分发。【 logger.setLevel() 为记录器设置日志级别（根据设置的日志级别决定日志信息是否传递给处理器）， handlers.setLevel 为处理器设置日志级别（根据每个处理器设置的日志级别决定日志信息是否输出至指定地方）。】

② handlers.setFormatter() ：为该处理器选择一个格式化器。

③ handlers.addFilter() 和 handlers.removeFilter()：分别配置和取消配置处理器上的过滤器对象。

五、Formatters

Formatter对象设置日志信息最后的规则、结构和内容；【日志生成时的样式】

默认的时间格式为%Y-%m-%d %H:%M:%S。

如下图为Formatter常用的一些信息：

 六、代码示例

代码示例1：get_logger(获取日志器)： 

# 导包
import logging.handlers
import os
import time


# 新建 类
class Logs:
    root_path = os.path.abspath(os.path.dirname(__file__)).split('shippingSchedule')[0]

    # 新建一个日志器变量
    __logger = None
    # 定义生成日志文件的时间
    __log_time = time.strftime("%Y-%m-%d", time.localtime())

    # 新建获取日志器的方法
    @classmethod
    def get_logger(cls):
        # 判断日志器为空：
        if cls.__logger is None:
            # 获取日志器【Logger 暴露了应用程序代码能直接使用的接口】
            cls.__logger = logging.getLogger()  # 包名.方法名直接调用logging包下的初始化模块中的getLogger()返回RootLogger
            # 修改默认级别
            cls.__logger.setLevel(logging.DEBUG)
            log_path = cls.root_path + os.sep + "python--log" + os.sep + "info.python--log" + "_" + cls.__log_time
            # 获取处理器【Handler将（记录器产生的）日志记录发送至合适的目的地】
            th = logging.handlers.TimedRotatingFileHandler(filename=log_path,
                                                           when="midnight",
                                                           interval=1,
                                                           backupCount=3,
                                                           encoding="utf-8")
            # 获取格式化器【Filter提供了更好的粒度控制，它可以决定输出哪些日志记录】
            fmt = "%(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s"
            fm = logging.Formatter(fmt)  # Formatter 指明了最终输出中日志记录的布局。
            # 将格式化器添加到处理器中
            th.setFormatter(fm)
            # 将处理器添加到日志器中
            cls.__logger.addHandler(th)
        # 返回日志器
        return cls.__logger


if __name__ == '__main__':
    log = Logs.get_logger()
    log.info("测试信息级别日志")
    log.error("测试错误级别")

代码示例2：输出log到控制台以及同时将log写入log文件

# encoding:utf-8
import logging
from logging import handlers


class Logger(object):
    level_relations = {
        'debug': logging.DEBUG,
        'info': logging.INFO,
        'warning': logging.WARNING,
        'error': logging.ERROR,
        'crit': logging.CRITICAL
    }  # 日志级别关系映射

    def __init__(self, filename, level='info', when='D', backCount=3,
                 fmt='%(asctime)s -%(name)s- %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
        self.logger = logging.getLogger(filename)  # 获取日志器（filename是日志器的名称，如果不填，默认日志器名称为root）
        format_str = logging.Formatter(fmt)  # 设置日志格式
        self.logger.setLevel(self.level_relations.get(level))  # 设置日志级别
        sh = logging.StreamHandler()  # 输出至控制台
        sh.setFormatter(format_str)  # 设置输出至控制台上日志格式
        th = handlers.TimedRotatingFileHandler(filename=filename, when=when, backupCount=backCount,
                                               encoding='utf-8')  # 往文件里写入#指定间隔时间自动生成文件的处理器
        # 实例化TimedRotatingFileHandler
        # interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
        # S 秒
        # M 分
        # H 小时、
        # D 天、
        # W 每星期（interval==0时代表星期一）
        # midnight 每天凌晨
        th.setFormatter(format_str)  # 设置文件里写入的格式
        self.logger.addHandler(sh)  # 把对象加到logger里
        self.logger.addHandler(th)


if __name__ == '__main__':
    log = Logger('all.log', level='debug')
    log.logger.debug('debug')
    log.logger.info('info')
    log.logger.warning('警告')
    log.logger.error('报错')
    log.logger.critical('严重')
    Logger('error.log', level='error').logger.error('error')

代码示例3：输出log日志到控制台以及同时将log日志写入log文件+装饰器函数代替测试用例脚本中函数调用。

# -*- encoding:utf-8 -*-
import logging
import os
import time
import traceback
from functools import wraps

"""handlers是什么？"""
# logging模块中包含的类
# 用来自定义日志对象的规则（比如：设置日志输出格式、等级等）
# 常用子类：StreamHandler、FileHandler
# StreamHandler 控制台输出日志
# FileHandler 日志输出到文件

# 日志文件路径
LOG_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "log")
if not os.path.exists(LOG_PATH):
    os.mkdir(LOG_PATH)


class Logger:

    def __init__(self):
        # 创建日志路径和时间
        self.log_path = os.path.join(LOG_PATH, "{}.log".format(time.strftime("%Y%m%d")))

        # 创建一个logger日志对象,并传参为log日志器命名为log
        self.logger = logging.getLogger("log")

        # 为日志器设置默认的日志级别
        self.logger.setLevel(logging.DEBUG)

        # 创建日志格式对象
        self.formater = logging.Formatter('[%(asctime)s][%(filename)s %(lineno)d][%(levelname)s]: %(message)s')

        # 创建FileHandler对象（输出log至文件）
        self.file_handlers = logging.FileHandler(self.log_path, mode='a', encoding="UTF-8")
        # 创建StreamHandler对象（输出log至控制台）
        self.console_handlers = logging.StreamHandler()

        # FileHandler对象定义日志级别
        self.file_handlers.setLevel(logging.DEBUG)
        # StreamHandler对象定义日志级别
        self.console_handlers.setLevel(logging.DEBUG)

        # 设置FileHandler处理器的格式
        self.file_handlers.setFormatter(self.formater)
        # 设置StreamHandler处理器的格式
        self.console_handlers.setFormatter(self.formater)

        # logger日志对象加载FileHandler对象
        self.logger.addHandler(self.file_handlers)
        # logger日志对象加载StreamHandler对象
        self.logger.addHandler(self.console_handlers)


Logger = Logger().logger


# 定义一个装饰器，为修饰测试方法提供附加操作（测试方法调用前，测试方法调用后）
def decorate_log(func):
    @wraps(func)
    def log(*args, **kwargs):
        Logger.info(f'------开始执行{func.__name__}------')
        try:
            func(*args, **kwargs)
        except Exception as e:
            Logger.error(f'------{func.__name__}执行失败，失败原因：{e}------')
            Logger.error(f"{func.__name__} is error,here are details:{traceback.format_exc()}")
            raise e
        else:
            Logger.info(f'------{func.__name__}执行成功------')

    return log


@decorate_log
def hbq():
    assert 1 == 1


if __name__ == '__main__':
    hbq()

    # Logger.info("---测试开始---")
    # Logger.error("---测试结束---")
    # Logger.debug("---测试结束---")

衍生：结合代码示例3：

python装饰器functools.wraps(func)详解

1、先看一段代码：

def is_login(func):
    def foo(*args, **kwargs):
        return func(*args, **kwargs)

    return foo


def test():
    print('我是：', test.__name__)


@is_login
def test1():
    print('我是：', test1.__name__)


@is_login
def test2():
    print('我是：', test2.__name__)


if __name__ == '__main__':
    test()
    test1()
    test2()

运行结果：

我是： test
我是： foo
我是： foo

可以发现函数的函数名即 func.__name__已被装饰器改变,变成了装饰器内返回的函数的函数名

2、在装饰器内返回的函数的函数名上新增 @wraps 装饰器/ functools.wraps(func) 装饰器

from functools import wraps


def is_login(func):
    @wraps(func)
    def foo(*args, **kwargs):
        return func(*args, **kwargs)

    return foo


def test():
    print('我是：', test.__name__)


@is_login
def test1():
    print('我是：', test1.__name__)


@is_login
def test2():
    print('我是：', test2.__name__)


if __name__ == '__main__':
    test()
    test1()
    test2()

运行结果：

我是： test
我是： test1
我是： test2

结论：

 @wraps 可以保证被装饰器修饰的函数的 func.__name__ 的值即函数名保持不变。

装饰器的优化

以时间装饰器为例，进行优化

• 装饰器的统一模板

from functools import wraps
# 对函数的装饰器， 对类func最好为cls
def decorate(func):
    @wraps(func)
    # 增添或修改功能的函数
    def wrapper(*args,**kwargs):
                # 执行被装饰的函数
        result = func(*args,**kwargs) 
        # 返回结果
        return result
    # 返回内层函数
    return wrapper

普通--时间装饰器

from functools import wraps
import time
from random import randint

def use_time(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        st_time = time.time()
        result = func(*args,**kwargs)
        end_time = time.time()
        print(f'{func.__name__}函数use_time:{end_time-st_time}s')
    return wrapper
 
    
@use_time
def foo():
    time.sleep(randint(1,3))

for _ in range(3):
    foo()

运行结果：

foo函数use_time:3.0130558013916016s
foo函数use_time:1.0116651058197021s
foo函数use_time:1.01423978805542s

下面对改装饰器进行优化(解耦)

• 可以发先上面时间装饰器计算的结果，只能在控制台上打印
• 那我们怎样才能将它输出为日志呢？？？
• 我们需要将他的结果进行自定输出

# 在增加一层函数
from functools import wraps
import time
from random import randint


def record(output):
    def use_time(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            st_time = time.time()
            func(*args, **kwargs)
            end_time = time.time()
            #             print(f'{func.__name__}函数use_time:{end_time-st_time}s')
            output(func.__name__, 'use', end_time - st_time)

        return wrapper

    return use_time


# 改装饰器的结果就可以自定义了，下面以print函数为例
@record(print)
def foo():
    time.sleep(randint(2, 5))


if __name__ == '__main__':
    foo()

结果输出日志

# 在增加一层函数
from functools import wraps
import time
from random import randint


def record(output):
    def use_time(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            st_time = time.time()
            func(*args, **kwargs)
            end_time = time.time()
            #             print(f'{func.__name__}函数use_time:{end_time-st_time}s')
            output(func.__name__, end_time - st_time)

        return wrapper

    return use_time


def write_log(name, content):
    with open('./time.log', 'a', encoding='utf-8')as f:
        f.write(f'{name}耗时：{content}\r\n')  # \r\n 换行


# 只需要将装饰器改为@record(write_log)
@record(write_log)
def foo():
    time.sleep(randint(2, 5))


if __name__ == '__main__':
    foo()