python中内置的日志模块logging用法详解

logging模块简介

python的logging模块提供了通用的日志系统，可以方便第三方模块或者是应用使用。这个模块提供不同的日志级别，并可以采用不同的方式记录日志，比如文件，http get/post，smtp，socket等，甚至可以自己实现具体的日志记录方式。
logging模块与log4j的机制是一样的，只是具体的实现细节不同。模块提供logger，handler，filter，formatter。

logger：提供日志接口，供应用代码使用。logger最长用的操作有两类：配置和发送日志消息。可以通过logging.getlogger(name)获取logger对象，如果不指定name则返回root对象，多次使用相同的name调用getlogger方法返回同一个logger对象。
handler：将日志记录（log record）发送到合适的目的地（destination），比如文件，socket等。一个logger对象可以通过addhandler方法添加0到多个handler，每个handler又可以定义不同日志级别，以实现日志分级过滤显示。
filter：提供一种优雅的方式决定一个日志记录是否发送到handler。
formatter：指定日志记录输出的具体格式。formatter的构造方法需要两个参数：消息的格式字符串和日期字符串，这两个参数都是可选的。

与log4j类似，logger，handler和日志消息的调用可以有具体的日志级别（level），只有在日志消息的级别大于logger和handler的级别。

logging用法解析

1. 初始化 logger = logging.getlogger(“endlesscode”)，getlogger()方法后面最好加上所要日志记录的模块名字，后面的日志格式中的%(name)s 对应的是这里的模块名字
2. 设置级别 logger.setlevel(logging.debug),logging中有notset < debug < info < warning < error < critical这几种级别，日志会记录设置级别以上的日志 3. handler，常用的是streamhandler和filehandler，windows下你可以简单理解为一个是console和文件日志，一个打印在cmd窗口上，一个记录在一个文件上 4. formatter，定义了最终log信息的顺序,结构和内容，我喜欢用这样的格式 '[%(asctime)s] [%(levelname)s] %(message)s', '%y-%m-%d %h:%m:%s'， %(name)s logger的名字 %(levelname)s 文本形式的日志级别 %(message)s 用户输出的消息 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 %(levelno)s 数字形式的日志级别 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有 %(filename)s 调用日志输出函数的模块的文件名 %(module)s 调用日志输出函数的模块名 %(funcname)s 调用日志输出函数的函数名 %(lineno)d 调用日志输出函数的语句所在的代码行 %(created)f 当前时间，用unix标准的表示时间的浮 点数表示 %(relativecreated)d 输出日志信息时的，自logger创建以 来的毫秒数 %(thread)d 线程id。可能没有 %(threadname)s 线程名。可能没有 %(process)d 进程id。可能没有 5. 记录 使用object.debug(message)来记录日志 下面来写一个实例，在cmd窗口上只打出error以上级别的日志，但是在日志中打出debug以上的信息

import logging
logger = logging.getlogger(“simple_example”)
logger.setlevel(logging.debug)
# 建立一个filehandler来把日志记录在文件里，级别为debug以上
fh = logging.filehandler(“spam.log”)
fh.setlevel(logging.debug)
# 建立一个streamhandler来把日志打在cmd窗口上，级别为error以上
ch = logging.streamhandler()
ch.setlevel(logging.error)
# 设置日志格式
formatter = logging.formatter(“%(asctime)s – %(name)s – %(levelname)s – %(message)s”)
ch.setformatter(formatter)
fh.setformatter(formatter)
#将相应的handler添加在logger对象中
logger.addhandler(ch)
logger.addhandler(fh)
# 开始打日志
logger.debug(“debug message”)
logger.info(“info message”)
logger.warn(“warn message”)
logger.error(“error message”)
logger.critical(“critical message”)

运行一下将会看到cmd窗口只记录两条，spam.log中记录了五条日志

当一个项目比较大的时候，不同的文件中都要用到log,可以考虑将其封装为一个类来使用

#! /usr/bin/env python
#coding=gbk
import logging,os
class logger:
def __init__(self, path,clevel = logging.debug,flevel = logging.debug):
self.logger = logging.getlogger(path)
self.logger.setlevel(logging.debug)
fmt = logging.formatter(‘[%(asctime)s] [%(levelname)s] %(message)s’, ‘%y-%m-%d %h:%m:%s’)
#设置cmd日志
sh = logging.streamhandler()
sh.setformatter(fmt)
sh.setlevel(clevel)
#设置文件日志
fh = logging.filehandler(path)
fh.setformatter(fmt)
fh.setlevel(flevel)
self.logger.addhandler(sh)
self.logger.addhandler(fh)
def debug(self,message):
self.logger.debug(message)
def info(self,message):
self.logger.info(message)
def war(self,message):
self.logger.warn(message)
def error(self,message):
self.logger.error(message)
def cri(self,message):
self.logger.critical(message)
if __name__ ==’__main__’:
logyyx = logger(‘yyx.log’,logging.error,logging.debug)
logyyx.debug(‘一个debug信息’)
logyyx.info(‘一个info信息’)
logyyx.war(‘一个warning信息’)
logyyx.error(‘一个error信息’)
logyyx.cri(‘一个致命critical信息’)

这样每次使用的时候只要实例化一个对象就可以了

logobj = logger(‘filename’,clevel,flevel)

如果想在cmd窗口中对于error的日志标红，warning的日志标黄，那么可以使用ctypes模块

#! /usr/bin/env python
#coding=gbk
import logging,os
import ctypes
foreground_white = 0x0007
foreground_blue = 0x01 # text color contains blue.
foreground_green= 0x02 # text color contains green.
foreground_red = 0x04 # text color contains red.
foreground_yellow = foreground_red | foreground_green
std_output_handle= -11
std_out_handle = ctypes.windll.kernel32.getstdhandle(std_output_handle)
def set_color(color, handle=std_out_handle):
bool = ctypes.windll.kernel32.setconsoletextattribute(handle, color)
return bool
class logger:
def __init__(self, path,clevel = logging.debug,flevel = logging.debug):
self.logger = logging.getlogger(path)
self.logger.setlevel(logging.debug)
fmt = logging.formatter(‘[%(asctime)s] [%(levelname)s] %(message)s’, ‘%y-%m-%d %h:%m:%s’)
#设置cmd日志
sh = logging.streamhandler()
sh.setformatter(fmt)
sh.setlevel(clevel)
#设置文件日志
fh = logging.filehandler(path)
fh.setformatter(fmt)
fh.setlevel(flevel)
self.logger.addhandler(sh)
self.logger.addhandler(fh)
def debug(self,message):
self.logger.debug(message)
def info(self,message):
self.logger.info(message)
def war(self,message,color=foreground_yellow):
set_color(color)
self.logger.warn(message)
set_color(foreground_white)
def error(self,message,color=foreground_red):
set_color(color)
self.logger.error(message)
set_color(foreground_white)
def cri(self,message):
self.logger.critical(message)
if __name__ ==’__main__’:
logyyx = logger(‘yyx.log’,logging.warning,logging.debug)
logyyx.debug(‘一个debug信息’)
logyyx.info(‘一个info信息’)
logyyx.war(‘一个warning信息’)
logyyx.error(‘一个error信息’)
logyyx.cri(‘一个致命critical信息’)

多模块使用logging
logging模块保证在同一个python解释器内，多次调用logging.getlogger(‘log_name’)都会返回同一个logger实例，即使是在多个模块的情况下。所以典型的多模块场景下使用logging的方式是在main模块中配置logging，这个配置会作用于多个的子模块，然后在其他模块中直接通过getlogger获取logger对象即可。
配置文件：

[loggers]
keys=root,main
[handlers]
keys=consolehandler,filehandler
[formatters]
keys=fmt
[logger_root]
level=debug
handlers=consolehandler
[logger_main]
level=debug
qualname=main
handlers=filehandler
[handler_consolehandler]
class=streamhandler
level=debug
formatter=fmt
args=(sys.stdout,)
[handler_filehandler]
class=logging.handlers.rotatingfilehandler
level=debug
formatter=fmt
args=(‘tst.log’,’a’,20000,5,)
[formatter_fmt]
format=%(asctime)s – %(name)s – %(levelname)s – %(message)s
datefmt=

主模块main.py：

import logging
import logging.config
logging.config.fileconfig(‘logging.conf’)
root_logger = logging.getlogger(‘root’)
root_logger.debug(‘test root logger…’)
logger = logging.getlogger(‘main’)
logger.info(‘test main logger’)
logger.info(‘start import module \’mod\’…’)
import mod
logger.debug(‘let\’s test mod.testlogger()’)
mod.testlogger()
root_logger.info(‘finish test…’)

子模块mod.py：

import logging
import submod
logger = logging.getlogger(‘main.mod’)
logger.info(‘logger of mod say something…’)
def testlogger():
logger.debug(‘this is mod.testlogger…’)
submod.tst()

子子模块submod.py：

import logging
logger = logging.getlogger(‘main.mod.submod’)
logger.info(‘logger of submod say something…’)
def tst():
logger.info(‘this is submod.tst()…’)

然后运行python main.py，控制台输出：

2012-03-09 18:22:22,793 – root – debug – test root logger…
2012-03-09 18:22:22,793 – main – info – test main logger
2012-03-09 18:22:22,809 – main – info – start import module ‘mod’…
2012-03-09 18:22:22,809 – main.mod.submod – info – logger of submod say something…
2012-03-09 18:22:22,809 – main.mod – info – logger say something…
2012-03-09 18:22:22,809 – main – debug – let’s test mod.testlogger()
2012-03-09 18:22:22,825 – main.mod – debug – this is mod.testlogger…
2012-03-09 18:22:22,825 – main.mod.submod – info – this is submod.tst()…
2012-03-09 18:22:22,841 – root – info – finish test…

可以看出，和预想的一样，然后在看一下tst.log，logger配置中的输出的目的地：

2012-03-09 18:22:22,793 – main – info – test main logger
2012-03-09 18:22:22,809 – main – info – start import module ‘mod’…
2012-03-09 18:22:22,809 – main.mod.submod – info – logger of submod say something…
2012-03-09 18:22:22,809 – main.mod – info – logger say something…
2012-03-09 18:22:22,809 – main – debug – let’s test mod.testlogger()
2012-03-09 18:22:22,825 – main.mod – debug – this is mod.testlogger…
2012-03-09 18:22:22,825 – main.mod.submod – info – this is submod.tst()…

tst.log中没有root logger输出的信息，因为logging.conf中配置了只有main logger及其子logger使用rotatingfilehandler，而root logger是输出到标准输出。