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()

 

去期待陌生，去拥抱惊喜。