python日志处理模块

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

结果如下

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

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。