Python里logger模块的调用

之前学习了logger模块的使用，可以自定义一个logger实现同时向文件和屏幕输出。但是在使用软件目录开发规范来组织代码的时候，需要将代码做成一个一个的代码块，就遇到了一系列的问题。

首先是自定义logger的例子：

import logging
# 先创建一个logger
logger = logging.getLogger(__name__)  # 定义Logger的名字，之前直接用logging调用的名字是root，日志格式用%(name)s可以获得。这里的名字也可以自定义比如"TEST"
logger.setLevel(logging.DEBUG)  # 低于这个级别将被忽略，后面还可以设置输出级别
# 创建handler和输出级别
ch = logging.StreamHandler()  # 输出到屏幕的handler
ch.setLevel(logging.INFO)  # 输出级别和上面的忽略级别都不一样，可以看一下效果
fh = logging.FileHandler('access.log',encoding='utf-8')  # 输出到文件的handler，定义一下字符编码
fh.setLevel(logging.WARNING)
# 创建日志格式，可以为每个handler创建不同的格式
ch_formatter = logging.Formatter('%(name)s %(asctime)s {%(levelname)s}:%(message)s',datefmt='%Y-%m-%d %H:%M:%S')  # 关键参数datefmt自定义日期格式
fh_formatter = logging.Formatter('%(asctime)s %(module)s-%(lineno)d [%(levelname)s]:%(message)s',datefmt='%Y/%m/%d %H:%M:%S')
# 把上面的日志格式和handler关联起来
ch.setFormatter(ch_formatter)
fh.setFormatter(fh_formatter)
# 将handler加入logger
logger.addHandler(ch)
logger.addHandler(fh)
# 以上就完成了，下面来看一下输出的日志
logger.debug('logger test debug')
logger.info('logger test info')
logger.warning('logger test warning')
logger.error('logger test error')
logger.critical('logger test critical')

然后就是做成模块，需要把代码写到函数中。并且因为写到了函数中，就可以传入参数了。这里将日志的name作为参数传入，需要的话还可以传入几个日志级别。

# 把下面的内容写入log.py文件，然后可以作为模块在别的程序中调用
import logging
def log_mod(name):
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)
    fh = logging.FileHandler('access.log',encoding='utf-8')
    fh.setLevel(logging.WARNING)
    ch_formatter = logging.Formatter('%(module)s-%(lineno)d %(levelname)s:%(message)s')
    fh_formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s:%(message)s',datefmt='%Y/%m/%d %H:%M:%S')
    ch.setFormatter(ch_formatter)
    fh.setFormatter(fh_formatter)
    logger.addHandler(ch)
    logger.addHandler(fh)
    # 这里需要把logger返回
    return logger

然后在另外一个文件里调用这个log模块里的log_mod方法：

import log
# 下面的语句每执行1次，就会多打印1行日志
log.log_mod("test").info("test 1")
log.log_mod("test").info("test 2")
log.log_mod("test").info("test 3")
input("看看每次名字都不同的情况")
# 下面的因为名字不同，就不会有问题
log.log_mod("test1").info("In test1 A")
log.log_mod("test2").info("In test2 A")
log.log_mod("test3").info("In test3 A")

结果发现，后面每调用一次都会多打印一行。原因应该是多次调用了函数，生成了多个方法。所以只要保证只调用1次函数就可以避免这个问题。

import log
log1 = log.log_mod("test1")  # 只调用了一次log.log()
log1.info("In log1 A")
log1.info("In log1 B")
log1.info("In log1 C")
log2 = log.log_mod("test2")  # 如果是别的日志name，那么再调用一次，名字不同不会有问题
log2.info("In log2 A")
log2.info("In log2 B")
log2.info("In log2 C")

但是这还没完，马上问题又发生了。这是在函数中发生的：

import log
def log_test1():
    log1 = log.log_mod("test")  # 只调用了一次log.log()
    log1.info("In log1 A")
    log1.info("In log1 B")
    log1.info("In log1 C")
    log_test2()
def log_test2():
    log2 = log.log_mod("test")  # 这里的日志name和上面的一样,等于又调用了1次
    log2.info("In log2 A")
    log2.info("In log2 B")
    log2.info("In log2 C")
log_test1()

log_test2里又调用了一次log.log_mod导致之后的日志又多次打印了。这里如果把log2的赋值语句注释掉，再把下面的log2改成log1也是不行的，会报错。

但是这样可以：

import log
def log_test1():
    log1 = log.log_mod("test")  # 只调用了一次log.log()
    log1.info("In log1 A")
    log1.info("In log1 B")
    log1.info("In log1 C")
    log_test2(log1)
def log_test2(log2):
    log2.info("In log2 A")
    log2.info("In log2 B")
    log2.info("In log2 C")
log_test1()

虽然好了，但是这样每次再调用函数都得把这个参数一直传递下去，很麻烦。而且也不利于以后的修改。

这个问题还得从源头上来解决，修改一下log模块：

import logging
def log_mod(name):
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)
    fh = logging.FileHandler('access.log',encoding='utf-8')
    fh.setLevel(logging.WARNING)
    ch_formatter = logging.Formatter('%(module)s-%(lineno)d %(levelname)s:%(message)s')
    fh_formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s:%(message)s',datefmt='%Y/%m/%d %H:%M:%S')
    ch.setFormatter(ch_formatter)
    fh.setFormatter(fh_formatter)
    logger.addHandler(ch)
    logger.addHandler(fh)
    # 这里需要把logger返回
    return logger
'''
下面是增加的赋值语句，调用log模块只需要调用下面的1个或多个变量就好了
不需要再调用上面的函数了
每个需要的日志name都先定义好一个变量
另外，下面的定义变量的部分，我是直接写在日志模块里了
应该也可以写到配置(settings 或者叫 conf)模块里，不知道哪个更好。
'''
log1 = log_mod("test1")
log2 = log_mod("test2")
log3 = log_mod("test3")

然后我们就直接调用在模块里定义好了变量：

from log import log1,log2,log3
def log_test1():
    log1.info("In log1 A")
    log1.info("In log1 B")
    log1.info("In log1 C")
    log_test2()
def log_test2():
    log2.info("In log2 A")
    log2.info("In log2 B")
    log2.info("In log2 C")
    log_test3()
def log_test3():
    log3.info("In log3 A")
    log3.info("In log3 B")
    log3.info("In log3 C")
log_test1()

输出没有问题，问题终于解决了。

重复打印的根本原因

这里再探究一下根本的原因。之所以会重复打印，原因是hangdler里面的内容，在上面的日志模块中加一句print：

import logging
def log_mod(name):
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)
    fh = logging.FileHandler('access.log',encoding='utf-8')
    fh.setLevel(logging.WARNING)
    ch_formatter = logging.Formatter('%(module)s-%(lineno)d %(levelname)s:%(message)s')
    fh_formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s:%(message)s',datefmt='%Y/%m/%d %H:%M:%S')
    ch.setFormatter(ch_formatter)
    fh.setFormatter(fh_formatter)
    print(logger.handlers)  # 在add前打印handler
    logger.addHandler(ch)
    logger.addHandler(fh)
    # 这里需要把logger返回
    return logger

从结果可以看到handlers是一个列表，每次addHandler就是在添加列表中的元素。而每次输出日志就是将日志信息传给每一个元素，所以多次add之后就重复打印了。

当然我们不能只规避add的这2行代码，def log_mod()的整段代码应该都是只需要执行一次就好了（除非函数的变量不同），上面的代码重复执行虽然不影响结果，但是也会影响效率。

日志等级

定义日志显示等级，使用setLevel方法：

import logging
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)  # 要使用logging.DEBUG必须要加载了logging的模块

这里要使用logging.DEBUG必须要先import logging模块。那么如果想要在别处（比如settings中）先定义好log等级，然后再在日志模块中使用变量调用的话。那么在settings里也要import logging，才能使用logging.DEBUG

或者也可以这样：

log_level = "logging.DEBUG"  # 这里先用字符串
import logging
logger = logging.getLogger(name)
logger.setLevel(eval(log_level))  # 然后这里再使用eval来解析这个字符串

但是查了help之后，这里也是可以使用×××来定义日志等级的：

import logging
help(logging)
# 在末尾处可以查到如下信息
'''
DATA
    BASIC_FORMAT = '%(levelname)s:%(name)s:%(message)s'
    CRITICAL = 50
    DEBUG = 10
    ERROR = 40
    FATAL = 50
    INFO = 20
    NOTSET = 0
    WARN = 30
    WARNING = 30
    __all__ = ['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', ...
    __status__ = 'production'
    lastResort = <_StderrHandler  (WARNING)>
    raiseExceptions = True
'''

好了，直接用数字在settings里给记录等级的变量预先赋值就好了。

新的心得

之前创建logger的使用的方法，会尝试获取已经有的logger，之前设置的内容都在的，然后在addHandler，就会往里追加。使同下面的方法，则每次都是重新创建一个新的logger：

# 之前创建logger的方法
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# 重新创建logger的方法
logger = logging.Logger(__name__, logging.DEBUG)

不过这个也只是表面上解决问题，因为其实每次还是要完全运行一遍创建过程的。所以我之前总结的是没有问题的，要避免重复执行创建logger的过程。只运行一次拿到对象后，每次都调用这个对象。

这里就补充一个重新创建logger的方法，并且如果这么创建的话，即使重复执行创建过程，也不会多次追加handler。