一 日志处理模块概述

申博手机APP:1 日志级别

日志级别level 数值
CRITICAL 50
ERROR 40
WARNING 30 ,默认日志级别
INFO 20
DEBUG 10
NOTSET 0,表示不设置

日志级别是指产生日志的严重程度
设置一个级别后,严重程度低于次级别的日志消息将会被忽略
数字越高,优先级别越高

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
import  logging
logging.basicConfig(level=logging.INFO)  #设置日志级别为info
def  add(x,y):
    logging.warning(x+y)  # 此处定义的日志级别是warning,因此能够被打印出来,默认的日志打印格式是 级别:用户:信息
t=threading.Timer(1,add,args=(3,4)) # 此处表示6秒后出结果
t.start()

结果如下

默认的日志打印格式是级别:用户:信息

2 格式字符串

1 常见格式

属性名 格式 描述
日志消息内容 %(message)s 当调用formatter.format() 时设置
asctime %(asctime)s 创建logrecord时的可读时间,默认格式是Y-m-d H:M:S, (逗号后面的数字是毫秒部分的时间)
函数名 %(funcName)s 日志调用所在的函数名
日志级别名称 %(levelname)s 消息级别名称,DEBUG,INFO,WARNING,ERROR,CRITICAL
日志级别数值 %(levelno)s 消息的级别数字DEBUG,INFO,WARNING,ERROR,CRITICAL
行号 %(lineno)d 日志调用所在源码行号
模块 %(module)s 模块(filename的名字部分)
进程ID %(process)d 进程ID
线程ID %(thread)d 线程ID
进程名称 %(processName)s 进程名
线程名称 %(threadName)s 线程名字

d 格式化成数字,s格式化成字符串

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
FORMAT="%(asctime)-15s\tThread Name: %(threadName)s\t%(message)s"  # 此处定义日志格式
import  logging
logging.basicConfig(level=logging.INFO,format=FORMAT)  #设置日志级别为info,此处format为引用日志格式
def  add(x,y):
    logging.warning(x+y)  # 此处定义的日志级别是warning,因此能够被打印出来

t=threading.Thread(target=add,args=(3,4),name='a1')
t.start()

结果如下

2 格式化时间字串

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
FORMAT="%(asctime)-15s\tThread Name: %(threadName)s\t%(message)s"  # 此处定义日志格式
import  logging
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt='%y-%m-%d %H:%M:%S %z')  #设置日志级别为info,此处format为引用日志格式,此处通过定义日志格式来
# 确定打印的日志为正常格式,其和%(asctime)互相作用
def  add(x,y):
    logging.warning(x+y)  # 此处定义的日志级别是warning,因此能够被打印出来

t=threading.Thread(target=add,args=(3,4),name='a1')
t.start()

结果如下

不同打印风格

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
FORMAT="%(asctime)-15s\tThread Name: %(threadName)s\t%(message)s"  # 此处定义日志格式
import  logging
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt='%y-%m-%d %H:%M:%S %z')  #设置日志级别为info,此处format为引用日志格式,此处通过定义日志格式来
# 确定打印的日志为正常格式,其和%(asctime)互相作用
def  add(x,y):
    logging.warning("%d",x+y)  # 此处定义的日志级别是warning,因此能够被打印出来,此处是c风格处理日志
    logging.info("{} 值为 {}".format(threading.enumerate(),x+y)) # 此处是format方式处理

t=threading.Thread(target=add,args=(3,4),name='a1')
t.start()

打印结果如下

3 新变量处理

定义一个新的变量来进行存储

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
FORMAT="%(asctime)s \t threadName: %(threadName)s \t %(message)s \t %(myname1)s"  # 此处定义日志格式,此处定义变量名为myname
import  logging
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt='%y-%m-%d %H:%M:%S %z')  #设置日志级别为info,此处format为引用日志格式,此处通过定义日志格式来
# 确定打印的日志为正常格式,其和%(asctime)互相作用
d={"myname1":"zhangsan"}  #此处定义变量值为zhangsan,是字典格式
def  add(x,y):
    logging.warning("%d",x+y,extra=d)  # 此处定义的日志级别是warning,因此能够被打印出来,此处是c风格处理日志,通过此处引用extra 字典得到结果
t=threading.Thread(target=add,args=(3,4),name='a1')
t.start()

结果如下

4 输出到文件

#!/usr/bin/python3.6
#conding:utf-8
import  threading
import time
FORMAT="%(asctime)s \t threadName: %(threadName)s \t %(message)s \t %(myname1)s"  # 此处定义日志格式,此处定义变量名为myname
import  logging
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt='%y-%m-%d %H:%M:%S %z',filename='/root/test.log')  #设置日志级别为info,此处format为引用日志格式,此处通过定义日志格式来
# 确定打印的日志为正常格式,其和%(asctime)互相作用,此处指定打印的路径,若不存在,则创建并追加,如此下面便不会再次打印
d={"myname1":"zhangsan"}  #此处定义变量值为zhangsan,是字典格式
def  add(x,y):
    logging.warning("%d",x+y,extra=d)  # 此处定义的日志级别是warning,因此能够被打印出来,此处是c风格处理日志,通过此处引用extra 字典得到结果
t=threading.Thread(target=add,args=(3,4),name='a1')
t.start()

结果如下

其相当于输出重定向到文件

二 logger 类

1 概述

使用工厂方法返回一个logger实例。
logger.getLogger([name=None)]
指定name,返回一个名称为name的Logger实例,如果再次使用相同的名字,是实例化一个对象。
未指定name,则返回logger实例,名称是root。及根Logger
Logger 是层次结构的,使用. 点号分割。如'a',或'a.b'或'a.b.c.d',a是a.b的父parent,a.b是a的子child,对于foo来说,名字为foo.bar,foo.bar.baz,foo.bam都是foo的后代。

2 基本实验

1 打印空name的logger

#!/usr/bin/python3.6
#conding:utf-8
import   logging

log=logging.getLogger()
print (log.name) #打印当前实例的名称,其默认名称为root
print (type(log))# 打印当前实例的类型

结果如下

2 打印非空name的logger

#!/usr/bin/python3.6
#conding:utf-8
import   logging

log=logging.getLogger('a')  # 此处定义其名称,
print (log.name) #打印当前实例的名称
print (log,type(log))# 打印当前实例的类型和实例情况

结果如下

3 打印层次化logger

#!/usr/bin/python3.6
#conding:utf-8
import   logging

#!/usr/bin/poython3.6
#conding:utf-8

import  logging
root=logging.getLogger()
print (root,id(root))  # 此处返回跟和跟地址

log=logging.getLogger('a')  # 此处定义其名称,
print (log.name) #打印当前实例的名称
print (log,type(log),log.parent,id(log),id(log.parent))# 打印当前实例的类型和实例情况及其父类情况,此处打印当前给情况和父根情况
#
log1=logging.getLogger('a.b')
print (log1.name)
print (log1,type(log1),log1.parent,id(log1.parent))# 此处打印当前根父跟情况

结果如下

上述表明,其a.b的父类是a,a的父类是root ,其直接存在父子级别

4 继承和重用

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO,datefmt='%Y-%m-%d %H:%M:%S',format=FORMAT)
root=logging.getLogger()
root.warning('my root')

log=logging.getLogger('a')  # 此处定义其名称,
log.warning('my log')

log1=logging.getLogger('a.b')
log1.warning('my log1')

5 规范化定义name

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO,datefmt='%Y-%m-%d %H:%M:%S',format=FORMAT)
root=logging.getLogger()
print (root,id(root))
root.warning('my root')
loga=logging.getLogger(__name__) # 此处使用模块名称进行定义名字
print (loga,id(loga),loga.name)
loga.warning('my loga')# loga.name 也不能在此中打印出来
logb=logging.getLogger("{}.{}".format(__name__,'abcd'))  # 此处使用模块名称下的具体方法定义名称,通过format进行字符串的拼接
print (logb,id(logb),logb.name)
logb.warning('my logb') # logb.name不能打印出来

结果如下

6 获取和修改日志级别

获取和设置相关级别

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO,datefmt='%Y-%m-%d %H:%M:%S',format=FORMAT)
root=logging.getLogger()
print (root,id(root))
print (root.getEffectiveLevel())#此处打印日志级别
loga=logging.getLogger(__name__) # 此处使用模块名称进行定义名字
loga.warning('my loga')# loga.name 也不能在此中打印出来
print (loga.getEffectiveLevel())#此处打印日志级别
logb=logging.getLogger("{}.{}".format(__name__,'abcd'))  # 此处使用模块名称下的具体方法定义名称,通过format进行字符串的拼接
logb.warning('my logb') # logb.name不能打印出来
logb.debug('my debug') # 此处的debug日志将不能被打印出来
print (logb.getEffectiveLevel())  #此处打印日志级别

结果如下

修改日志级别并进行配置和获取

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO,datefmt='%Y-%m-%d %H:%M:%S',format=FORMAT)
root=logging.getLogger()
print (root,id(root))
print (root.getEffectiveLevel())#此处打印日志级别
loga=logging.getLogger(__name__) # 此处使用模块名称进行定义名字
loga.info('my loga')# loga.name 也不能在此中打印出来
print (root.getEffectiveLevel())#此处打印日志级别
print (loga.getEffectiveLevel())#此处打印日志级别
loga.setLevel(28)# 此时日志级别位于INFO 和 WARNING之间,
print  (loga.getEffectiveLevel())  # 获取修改后的日志级别

print ('+'*20,'logb')
logb=logging.getLogger("{}.{}".format(__name__,'abcd'))  # 此处使用模块名称下的具体方法定义名称,通过format进行字符串的拼接
logb.info('my logb') # 此处因为自身没有配置日志级别,因此继承了上面的日志级别,因此,其不能打印
logb.setLevel(10)
logb.info('my logb') # 此处因为自身设置了日志级别,因此其可以打印
logb.warning('my debug')
print (logb.getEffectiveLevel())  #此处打印日志级别

结果如下

7 总结:

全局可以设定,但自己模块可以根据自己的情况进行调整和修改
上述用于设置模块和模块对应函数或类的日志级别,通过上述的定义可以确定打印日志的级别和相关的配置情况
向在模块级别的进行配置和修改日志的级别设置
想做个性化比较难
重要的主要是level和format 的情况

2 handler

1 概述

handler 控制日志信息的输出目的地,可以是控制台,文件
可以单独设置level
可以单独设置格式
可以设置过滤器


handler分为
1 StreamHandler # 不指定使用sys.stderr
A FileHandler # 文件输出
B _StderrHandler # 标准输出
2 NullHandler # 什么都不做

Handler父类 ,FileHandle和_StderrHandler和NullHandler是子类,子类可以继承父类的相关属性

2 handler 和 logger的关系

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.WARNING) #设置此对象的相关属性

h1=logging.StreamHandler()  # 实例化一个标准输出的handler
h1.setLevel(logging.INFO)  # 设置handler的级别
log1.addFilter(h1)  # 将h1加入到log1
log1.info('info  log1')  # 打印INFO日志。
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING

结果如下

此处表明,虽然handler设置了info级别,但其没不能影响log1的设置,仍然不能打印info级别

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.INFO) #设置此对象的相关属性

h1=logging.StreamHandler()  # 实例化一个标准输出的handler
h1.setLevel(logging.ERROR)  # 设置handler的级别
log1.addFilter(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')

log2=logging.getLogger('s.s1')  #此处继承了s1的属性
print (log2.getEffectiveLevel())
log2.warning('wangring  log2') #此处设置的warning 和handler中设置的ERROR不冲突,因为ERROR 不针对当前设置

结果如下

此处虽然handler设置了ERROR 级别,但info级别还是能够打印出来,其不会影响当前级别的日志,而继承的日志也没受到handler的影响直接打印

日志输出到文件

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.INFO) #设置此对象的相关属性

h1=logging.FileHandler('/root/test1.log')  # 实例化一个文件输出的handler
h1.setLevel(logging.ERROR)  # 设置handler的级别
log1.addHandler(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')
log1.error('error  log1')  #打印error级别

结果如下

文件中结果如下

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.WARNING) #设置此对象的相关属性

h1=logging.FileHandler('/root/test1.log')  # 实例化一个文件输出的handler
h1.setLevel(logging.INFO)  # 设置handler的级别
log1.addHandler(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')

结果如下

文件结果

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.WARNING) #设置此对象的相关属性

h1=logging.FileHandler('/root/test1.log')  # 实例化一个文件输出的handler
h1.setLevel(logging.INFO)  # 设置handler的级别
log1.addHandler(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')

log2=logging.getLogger('s.s1')
print (log2.getEffectiveLevel())
log2.info('log2 info')

文件结果

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.INFO) #设置此对象的相关属性

h1=logging.FileHandler('/root/test1.log')  # 实例化一个文件输出的handler
h1.setLevel(logging.INFO)  # 设置handler的级别
log1.addHandler(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')

log2=logging.getLogger('s.s1')
print (log2.getEffectiveLevel())
log2.info('log2 info')

结果

文件结果

3 添加格式化处理

#!/usr/bin/python3.6
#conding:utf-8
import  logging
FORMAT="%(asctime)s Threadinfo: %(threadName)s %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT)

log1=logging.getLogger('s')  #此处实例化出来一个对象
log1.setLevel(logging.INFO) #设置此对象的相关属性

h1=logging.FileHandler('/root/test1.log')  # 实例化一个文件输出的handler
h1.setLevel(logging.INFO)  # 设置handler的级别
fmtr=logging.Formatter("%(asctime)s Threadinfo: %(threadName)s %(message)s  %(thread)s")
h1.setFormatter(fmtr)
log1.addHandler(h1)  # 将h1加入到log1
log1.warning('warning  log1')  # 打印WARING ,此处只能打印WAENING
log1.info('info log1')

log2=logging.getLogger('s.s1')
print (log2.getEffectiveLevel())
log2.info('log2 info')

结果如下

文件结果如下

4 handlers 和 formatter

import logging

root=logging.getLogger()
root.setLevel(logging.ERROR)
print ('root',root.handlers)  #打印handler列表

h0=logging.StreamHandler()
h0.setLevel(logging.WARNING)
root.addHandler(h0)
print ('root',root.handlers)  # 打印列表

for h  in root.handlers:
    print ("root  handler = {} ,formatter= {}".format(h,h.formatter))  # 打印默认的formatter

结果如下

import logging

root=logging.getLogger()
root.setLevel(logging.ERROR)
print ('root',root.handlers)  #打印handler列表

h0=logging.StreamHandler()
h0.setLevel(logging.WARNING)
root.addHandler(h0)
print ('root',root.handlers)  # 打印列表

for h  in root.handlers:
    print ("root  handler = {} ,formatter= {}".format(h,h.formatter))  # 打印默认的formatter

log1=logging.getLogger('s')
log1.setLevel(logging.ERROR)
h1=logging.FileHandler('/root/test2.log')
log1.addHandler(h1)
print ('log1',log1.handlers)

log2=logging.getLogger('s.s1')
log2.setLevel(logging.CRITICAL)
h2=logging.FileHandler('/root/test2.log')
h2.setLevel(logging.WARNING)
print ('log2 formatter',h2.formatter)
# handler 默认无Formatter
f2=logging.Formatter("log2 %(name)s %(asctime)s %(message)s")
h2.setFormatter(f2)
print ('log2.formatter',h2.formatter)
log2.addHandler(h2)
print ('log2',log2.handlers)

结果为

文件结果为

5 总结:

1 每一个logger实例的level如同入水口,让水流进来,如果这个门槛太高,水流就不能进来,其相关低级别的信息一定不能被打印出来


2 如果level没有设置,则使用父类logger的,如果父类没有,则继续寻找父类的,最终找到root,而root的默认设置是WARNING


3 消息传递流程

在某个logger上产生某种级别的消息,首先和logger的level检查,如果消息level低于logger的EffectiveLevel有效级别,则丢弃消息,如果通过(大于等于)检查后,消息交给所有的handler处理,每一个handler需要和自己的level比较来决定是否处理,如果没有一个handler,或者消息已经被处handler处理过了,则需要通过本logger的propagate属性是否是True,True则会把这个消息继续传递给父logger,父logger成为新的logger。新的logger直接把消息交给新的logger的所有handler,handler都处理完了,如果paragate属性是True,新的logger的父成为新的logger,它的所有handler处理消息。


4 logger 实例初始化的paragate属性为True,及允许向父传递logger消息


5 logging.basicConfig


如果root没有handler,就默认创建一个StreamHandler ,如果设置了filename,则就创建了一个FileHandler,如果设置了format参数,它就会生成一个formatter对象,并把这个formatter加入到刚才创建的handler上,然后把这些handler加入到root.handlers列表上,level是设置给root logger的。如果root.handlers列表不是空,则logging.basicConfig的调用什么都不做。

6 filter过滤器

可以为handler增加过滤器,所以过滤器只影响某一个handler,不会影响整个处理流程


import logging
FORMAT="%(asctime)s %(thread)d  %(message)s"
logging.basicConfig(level=logging.ERROR,format=FORMAT,datefmt="%y-%m-%d %H:%M%S %z")  #重新格式化传值,定义日志输出到文件

root=logging.getLogger()
print (root,id(root))

loga=logging.getLogger('s') # 模块和模块下的某个函数或类
print (loga,id(loga),id(loga.parent))
loga.setLevel(logging.INFO)
print (loga.getEffectiveLevel()) #默认对应的是常量20

hadr=logging.FileHandler('/root/loga.txt')  # 定义,不指定则是标准错误输出
hadr.setLevel(logging.INFO)
fmtr=logging.Formatter("%(asctime)s %(thread)d  %(threadName)s   %(message)s")  #此处是一个实例。此处可以自己定义
hadr.setFormatter(fmtr)
fltr=logging.Filter('s') # 此处设置过滤器为s,则为s,s.s1均可通过
hadr.addFilter(fltr)
loga.addHandler(hadr)

logb=logging.getLogger('s.s1')
logb.getEffectiveLevel()
logb.info('logb info')

结果如下

文件结果如下


import logging
FORMAT="%(asctime)s %(thread)d  %(message)s"
logging.basicConfig(level=logging.ERROR,format=FORMAT,datefmt="%y-%m-%d %H:%M%S %z")  #重新格式化传值,定义日志输出到文件

root=logging.getLogger()
print (root,id(root))

loga=logging.getLogger('s') # 模块和模块下的某个函数或类
print (loga,id(loga),id(loga.parent))
loga.setLevel(logging.INFO)
print (loga.getEffectiveLevel()) #默认对应的是常量20

hadr=logging.FileHandler('/root/loga.txt')  # 定义,不指定则是标准错误输出
hadr.setLevel(logging.INFO)
fmtr=logging.Formatter("%(asctime)s %(thread)d  %(threadName)s   %(message)s")  #此处是一个实例。此处可以自己定义
hadr.setFormatter(fmtr)
fltr=logging.Filter('s') # 此处设置过滤器为s,则为s,s.s1均可通过
hadr.addFilter(fltr)
loga.addHandler(hadr)
loga.info('loga info')

logb=logging.getLogger('s.s1')
logb.getEffectiveLevel()
logb.info('logb info')

logc=logging.getLogger('s.s1')
logc.getEffectiveLevel()
logc.info('logc info')

结果如下

文件如下


import logging
FORMAT="%(asctime)s %(thread)d  %(message)s"
logging.basicConfig(level=logging.ERROR,format=FORMAT,datefmt="%y-%m-%d %H:%M%S %z")  #重新格式化传值,定义日志输出到文件

root=logging.getLogger()
print (root,id(root))

loga=logging.getLogger('s') # 模块和模块下的某个函数或类
print (loga,id(loga),id(loga.parent))
loga.setLevel(logging.INFO)
print (loga.getEffectiveLevel()) #默认对应的是常量20

hadr=logging.FileHandler('/root/loga.txt')  # 定义,不指定则是标准错误输出
hadr.setLevel(logging.INFO)
fmtr=logging.Formatter("%(asctime)s %(thread)d  %(threadName)s   %(message)s")  #此处是一个实例。此处可以自己定义
hadr.setFormatter(fmtr)
fltr=logging.Filter('a') # 此处设置过滤器为s,则为s,s.s1均可通过
hadr.addFilter(fltr)
loga.addHandler(hadr)
loga.info('loga info')

logb=logging.getLogger('s.s1')
logb.getEffectiveLevel()
logb.info('logb info')

logc=logging.getLogger('s.s1')
logc.getEffectiveLevel()
logc.info('logc info')

文件如下

消息loga,它的名字是's',因此过滤器名字设置为s,则s.s1,s.x和s都能通过,但其他的则不能通过,不设置过滤器名字,所有消息都能通过,设置为a,则和s,s.s1和s.s2无任何关系,因此其不能使用,实例对象只有一个,一旦同名,也是只有一个,线程的不安全不会影响logging,只会影响print。