江苏福彩快三:自动化之路,模块使用简介

作者:江苏福彩快三计算机网络

logging 模块是 python 的贰个平放模块,logging 的要害作用在于能够在相继模块之间共用,况且提供了不一样的日记等第,各模块将日志发送到同一文件或其余地点,最普及的动静是把音讯记录在 log 文件里。

logging 日志模块

 

中文官方
清晰明了,入门必备
承继讲的很棒
实例深入分析

使用python的logging模块,pythonlogging模块

一、从三个运用情状起初

 

支出三个日志系统, 既要把日志输出到调节台, 还要写入日志文件

 

Python代码  江苏福彩快三 1

  1. import logging  
  2.   
  3. # 成立贰个logger  
  4. logger = logging.getLogger('mylogger')  
  5. logger.setLevel(logging.DEBUG)  
  6.   
  7. # 创设一个handler,用于写入日志文件  
  8. fh = logging.FileHandler('test.log')  
  9. fh.setLevel(logging.DEBUG)  
  10.   
  11. # 更创建二个handler,用于出口到调节台  
  12. ch = logging.StreamHandler()  
  13. ch.setLevel(logging.DEBUG)  
  14.   
  15. # 定义handler的输出格式  
  16. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  
  17. fh.setFormatter(formatter)  
  18. ch.setFormatter(formatter)  
  19.   
  20. # 给logger添加handler  
  21. logger.addHandler(fh)  
  22. logger.addHandler(ch)  
  23.   
  24. # 记录一条日志  
  25. logger.info('foorbar')  

 

 

运营后, 在调控台和日志文件都有一条日志:

 

Java代码  江苏福彩快三 2

  1. 2011-08-31 19:18:29,816 - mylogger - INFO - foorbar  

 

 

二、logging模块的API

 

构成方面包车型地铁例证,大家说下几个最常使用的API

logging.``getLogger([name])重返二个logger实例,如果未有一些名name,再次来到root logger。只要name同样,再次回到的logger实例都以同三个並且独有一个,即name和logger实例是逐条对应的。那表示,没有须求把logger实例在每种模块中传送。只要理解name,就能够博取同八个logger实例
Logger.``setLevel(lvl)设置logger的level, level有以下多少个等第:
江苏福彩快三 3
NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL
假诺把looger的品级设置为INFO, 那么小于INFO级其他日志都不出口, 大于等于INFO级其余日记都输出

Python代码  江苏福彩快三 4

  1. logger.debug("foobar")    # 不输出   
  2. logger.info("foobar")        # 输出  
  3. logger.warning("foobar") # 输出  
  4. logger.error("foobar")      # 输出  
  5. logger.critical("foobar")    # 输出  

 Logger.``addHandler(hdlr)logger能够雇佣handler来帮它管理日志, handler首要有以下两种:StreamHandler: 输出到控制台``FileHandler:   输出到文件handler还足以设置本身的level以及出口格式。
logging.``basicConfig([*kwargs]) 这几个函数用来铺排root logger, 为root logger创设二个StreamHandler,   设置暗许的格式。* 那一个函数: logging.debug()、logging.info()、logging.warning()、   logging.error()、logging.critical() 假若调用的时候发掘root logger未有另外   handler, 会自动调用basicConfig增添一个handler* 借使root logger已有handler, 那个函数不做任何事情
行使basicConfig来布局root logger的出口格式和level:

Python代码  江苏福彩快三 5

  1. import logging  
  2. logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)  
  3. logging.debug('This message should appear on the console')  

 
三、关于root logger以及logger的老爹和儿子关系
近年来数次涉及root logger, 实际上logger实例之间还应该有父亲和儿子关系, root logger正是处于最顶层的logger, 它是富有logger的先世。如下图:江苏福彩快三 6root logger是私下认可的logger万一不创制logger实例, 直接调用logging.debug()、logging.info()logging.warning()、logging.error()、logging.critical()那个函数,那么使用的logger就是root logger, 它能够自行创立,也是单实例的。
怎么样得到root logger通过logging.getLogger()或者logging.getLogger("")得到root logger实例。
默认的levelroot logger默认的level是logging.WARNING
怎么着表示父亲和儿子关系logger的name的命名形式得以象征logger之间的父亲和儿子关系. 举个例子:parent_logger = logging.getLogger('foo')child_logger = logging.getLogger('foo.bar')
什么是effective levellogger有叁个定义,叫effective level。 就算三个logger未有出示地设置level,那么它就用老爹的level。如若老爹也远非显得地设置level, 就用阿爹的老爹的level,以此推....最终达到root logger,一定设置过level。默以为logging.WARAV4NINGchild loggers获得音信后,既把音讯分发给它的handler管理,也会传递给全数祖先logger管理,
来看四个例子

Python代码  江苏福彩快三 7

  1. import logging  
  2.   
  3. # 设置root logger  
  4. r = logging.getLogger()  
  5. ch = logging.StreamHandler()  
  6. ch.setLevel(logging.DEBUG)  
  7. formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')  
  8. ch.setFormatter(formatter)  
  9. r.addHandler(ch)  
  10.   
  11. # 创制二个logger作为阿爸  
  12. p = logging.getLogger('foo')  
  13. p.setLevel(logging.DEBUG)  
  14. ch = logging.StreamHandler()  
  15. ch.setLevel(logging.DEBUG)  
  16. formatter = logging.Formatter('%(asctime)s - %(message)s')  
  17. ch.setFormatter(formatter)  
  18. p.addHandler(ch)  
  19.   
  20. # 创设四个孩子logger  
  21. c = logging.getLogger('foo.bar')  
  22. c.debug('foo')  

 输出如下:

Python代码  江苏福彩快三 8

  1. 2011-08-31 21:04:29,893 - foo  
  2. 2011-08-31 21:04:29,893 - DEBUG - foo  

可知, 孩子logger没有别的handler,所以对音信不做拍卖。然而它把音讯转发给了它的老爸以及root logger。最后输出两条日志。

参考地址

模块级函数

  1. logging 的日志等级

一:概述

在事实上项目中,必要对一部分数量举行日志记录,并将日志记录到区别的存款和储蓄单元中,比如数据库,文本,或然推送到图片化界面中,当需求时开掘自身完成多少个日
志库其实是要异常的大的代价,因而,第三方的日志库上进展定制化处理正文内容是对logging的敞亮和应用方法,特别有帮衬
1:三个主要类,使用官方文书档案中的归纳:

  logger 提供了应用程序能够一向运用的接口;
  handler 将(logger制造的)日志记录发送到合适的指标输出;
  filter 提供了细度设备来支配输出哪条日志记录;用处不太大
  formatter 决定日志记录的末尾输出格式

2:模块级函数

  logging.getLogger([name]): #归来一个logger对象,若无一点点名名字将回来root logger,最常用
  logging.basicConfig(): #给logger对象的布局管理函数 ,有的时候用
  logging.debug()logging.info()logging.warning()logging.error()logging.critical(): #logger的日志等级

 

python中的logging模块,暗许写的日志文件贮存在何地?

日志文件对象配置的时候,是要填日志文件的地点的呦,作者都是按项目供给放置的。
暗中同意的未有色金属商量所究过。  

多年来写四个爬虫系统,需求选择python的日记记录模块,于是便学习了一晃。
python的标准库里的日志系统从Python2.3开始补助。只要import logging那些模块就可以使用。假若你想付出叁个日志系统, 既要把日记输出到调控台, 还要写入日志文件,只要这么使用:

logging.getLogger([name]):重回三个logger对象,若无一点名名字将重回root logger
logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical():设定root logger的日志等第
logging.basicConfig():用暗中同意Formatter为日志系统创制二个StreamHandler,设置基础配置并加到root logger中

```python
 
In [6]: import logging
 
In [7]: logging.NOTSET
Out[7]: 0
 
In [8]: logging.DEBUG
Out[8]: 10
 
In [9]: logging.INFO
Out[9]: 20
 
In [10]: logging.WARN
Out[10]: 30
 
In [11]: logging.ERROR
Out[11]: 40
 
In [12]: logging.CRITICAL
Out[12]: 50
 
In [13]: logging._levelNames
Out[13]:
{0: 'NOTSET',
 10: 'DEBUG',
 20: 'INFO',
 30: 'WARNING',
 40: 'ERROR',
 50: 'CRITICAL',
 'CRITICAL': 50,
 'DEBUG': 10,
 'ERROR': 40,
 'INFO': 20,
 'NOTSET': 0,
 'WARN': 30,
 'WARNING': 30}
```
logging 模块共有 6 个 level,如下所示:

二: logging职业流演示

 

 

cat demo.py
#coding:utf-8
import logging
# 创建三个logger命名称为mylogger, %(name)s可调用那一个名字
mylogger = logging.getLogger('mylogger')
mylogger.setLevel(logging.DEBUG)
# 定义日志输出格式formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(filename)s- %(levelname)s - %(message)s')
# 创造贰个handler,用于写入日志文件,只输出debug等第以上的日记,并调用定义的输出格式
fh = logging.FileHandler('test.log')
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
# 再创设五个handler,用于出口到调控台, 日常不用
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
# 给我们开端实例化的logger对象增多handler
mylogger.addHandler(fh)
mylogger.addHandler(ch)
# 直接在本模块中调用记录两条日志——生育条件会封装成函数调用
mylogger.info('foorbar')
mylogger.debug('just a test ')
$ python demo.py
2015-10-30 15:44:01,722 - mylogger - test1.py- INFO - foorbar
2015-10-30 15:44:01,723 - mylogger - test1.py- DEBUG - just a test
精粹实例

python logging 定向不出口到荧屏?

那您想出口到哪?截获sys.stdout就能够了  

一、从三个施用情状最初 开采八个日记系统, 既要把日志输出到控制台, 还要写入日志文件 Pytho...

复制代码代码如下:

示例:logging_level_example.py

Level Value Usage
C奥迪Q5ITICAL 50 严重错误,注脚程序已不能承袭运营了
ELANDRO哈弗 40 严重的难点,程序已不能够施行一些成效了
WAHavalNING 30 未来只怕会爆发难题,但足以运作
INFO 20 表明程序按预想的专门的工作
DEBUG 10 用于调试时使用
NOTSET 0 可寄存程序输出的万事新闻
示例:
 
 
#!/usr/bin/env python
# coding:utf-8
 
import logging
 
# 设置使用的日记文件,日志品级,文件读写格局
logging.basicConfig(filename='example.log',level=logging.DEBUG,filemode='w')
logging.debug('This is debug level')
logging.info('This is info level')
logging.warning('This is warning level')
logging.error('This is error level')
logging.critical('This is critical level')
翻开日志
# cat example.log
DEBUG:root:This is debug level
INFO:root:This is info level
WARNING:root:This is warning level
ERROR:root:This is error level
CRITICAL:root:This is critical level
 
留心:logging 模块的日记输出等第私下认可是 warning 等第,所以小于私下认可级其余全都不会写入到文件。root 代表 log 等第的根节点。

三:logging模块的API

1:logging.getLogger([name])
回来三个logger实例,若无一点点名name,重返root logger。只要name一样,重临的logger实例都以同二个还要唯有贰个,即name和logger实例是逐条对
应的。那代表,没有须要把logger实例在一一模块中传递。只要理解name,就会博得同多少个logger实例
2:logger.setLevel(lvl)——设置logger的level,
level有以下几个等级:
NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL
现在和过去特别不相同日志品级相应的数字相比较
级别 数值
CRITICAL 50
ERROR 40
WARNING 30
INFO 20
DEBUG 10
NOTSET 0
比如把logger的等第设置为INFO, 那么小于INFO等第的日志都不出口, 大于等于INFO级其他日记都输出。也就意味着同三个logger实例,假若几个地点调用,会
并发众多再一次的日记
logger.debug("debug") # 不输出
logger.info("info") # 输出
logger.warning("warning") # 输出
logger.error("error") # 输出
logger.critical("critical") # 输出
3:logger.addHandler(hd)—— logger雇佣handler来帮它管理日志
handler对象承担发送有关的音信到钦赐目标地。Python的日志系统有八种Handler能够利用。有些Handler能够把新闻输出到调节台,某些Logger能够把音讯输
出到文件,还某些Handler能够把新闻发送到互联网上。要是以为非常不够用,还足以编写制定本身的Handler。能够透过addHandler()方法增多三个多handler
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/三千/XP的事件日志
logging.handlers.MemoryHandler: #日记输出到内部存款和储蓄器中的制订buffer
由于StreamHandlerFileHandler是常用的日志管理格局,所以直接包涵在logging模块中,而别的措施则含有在logging.handlers模块中,
handle常见调用
Handler.setLevel(lel) #钦点被管理的音信等级,低于lel级其他音讯将被忽视
Handler.setFormatter() #给这一个handler采取三个格式
Handler.addFilter(filt)、Handler.removeFilter(filt):#新扩展或删除二个filter对象
举多少个栗子
1: logging内部调用——测量试验学习就能够
cat demo.py
import logging
import logging.handlers
LOG_FILE = 'api.log'
#定义日志文件切割法则最多备份5个日志文件,各类日志文件最大10M
handler = logging.handlers.RotatingFileHandler(LOG_FILE, maxBytes = 10*1024*1024, backupCount = 5)
#handler=logging.handlers.TimedRotatingFileHandler(LOG_FILE, when='midnight') #每一天零点切换
#定义日志输出格式
fmt = '%(asctime)s - %(filename)s:%(lineno)s - %(name)s - %(message)s'
formatter = logging.Formatter(fmt) # 实例化formatter
handler.setFormatter(formatter) # 为handler添加formatter
#实例化一个logger对象,并为其绑定handle
mylogger = logging.getLogger('test')
mylogger.addHandler(handler) # 为mylogger添加handler
mylogger.setLevel(logging.DEBUG) # 为mylogger设置输出品级
#调用mylogger
mylogger.info('first info message')
mylogger.debug('first debug message')
2: logging封装为函数——适用生产境况中
cat util.py
#/usr/bin/env python
#coding:utf-8
import logging,logging.handlers
def WriteLog(log_name):
log_filename = "/tmp/test.log"
log_level = logging.DEBUG
format = logging.Formatter('%(asctime)s %(filename)s [line:%(lineno)2d]-%(funcName)s %(levelname)s %(message)s')
handler = logging.handlers.RotatingFileHandler(log_filename, mode='a', maxBytes=10*1024*1024, backupCount=5)
handler.setFormatter(format)
logger = logging.getLogger(log_name)
logger.addHandler(handler)
logger.setLevel(log_level)
return logger #函数最后将实例化的logger对象回来,前面平素调用就可以
if __name__ == "__main__":
WriteLog('api').info('123') #模块内部直接调用函数。等价上边两行,下边包车型地铁艺术不引进
# writelog = WriteLog('api')
# writelog.info('123')
'''
外界程序调用函数
cat test.py
import util
def index()
util.WriteLog('api').info('123')
index()
'''
4:logging.basicConfig([**kwargs])——加载logger的每一种布置参数,糟糕用
cat test.py
import logging
logging.basicConfig(level=logging.DEBUG, #出口debug及其等级更加高端别的日志
format='%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%d %b %Y %H:%M:%S',
filename='myapp.log', #日志文件输出的文书地方,不写暗中认可打字与印刷到桌面
filemde='w')
logging.debug("this is debug message")
logging.info("this is info message")
logging.warning("this is warning message")
tail -f myapp.log
30 Oct 2015 14:18:51 test.py [line:8] DEBUG this is debug message
30 Oct 2015 14:18:51 test.py [line:9] INFO this is info message
30 Oct 2015 14:18:51 test.py [line:10] WARNING this is warning message
关于logging.basicConfig函数的常用配置:
filename: 内定日志文件名
filemode: 和file函数意义同样,钦定日志文件的展开格局,'w'或'a'
datefmt: 指定时间格式,同time.strftime()
level: 设置日志等第,默以为logging.WALX570NING,即warning及等第更加高的日记才输出
stream: 钦定将日志的输出流,可以钦赐输出到sys.stderr,sys.stdout也许文件,私下认可输出到sys.stderr,当stream和filename同有时候指定期,stream被
忽略
format: 钦点输出的格式和内容,format能够出口非常多有用音信,如上例所示:
%(name)s 打印logger名,默认为root
%(levelno)s: 打字与印刷日志品级的数值
%(levelname)s: 打字与印刷日志级小名称
%(pathname)s: 打印当前实行顺序的门径,其实正是sys.argv[0]
%(filename)s: 打字与印刷当前试行顺序名
%(funcName)s: 打字与印刷日志的当前函数
%(lineno)d: 打印日志的此时此刻行号
%(asctime)s: 打印日志的时刻
%(message)s: 打字与印刷日志新闻
%(thread)d: 打字与印刷线程ID
%(threadName)s: 打字与印刷线程名称
%(process)d: 打字与印刷进程ID
5: logging.config模块通过布置文件的主意,加载logger的参数——最棒用的议程
cat logger.conf
# 定义logger模块,root是父类,必须存在的,其余的是自定义。
# logging.getLogger(NAME)就相当于向logging模块注册了实例化了
# name 中用 . 表示 log 的后续关系
[loggers]
keys=root,example01,example02
# [logger_xxxx] logger_模块名称
# level 级别,级别有DEBUG、INFO、WARNING、ERROR、CRITICAL
# handlers 管理类,可以有多少个,用逗号分开
# qualname logger名称,应用程序通过 logging.getLogger获取。对于不可能赢得的称呼,则记录到root模块。
# propagate 是或不是持续父类的log新闻,0:否 1:是
[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
# [handler_xxxx]
# class handler类名
# level 日志等级
# formatter,上面定义的formatter
# args handler开始化函数参数
[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=%(asctime)s%(name)-12s: %(levelname)-8s %(message)s
datefmt=%a, %d %b %Y %H:%M:%S
调用
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')
生育条件中动用案例——通过函数定义调用
A:定义到工具模块中
cat util.py
import logging,
import logging.config
def write_log(loggername):
work_dir = os.path.dirname(os.path.realpath(__file__))
log_conf= os.path.join(work_dir, 'conf/logger.conf')
logging.config.fileConfig(log_conf)
logger = logging.getLogger(loggername)
return logger
B: 外界模块调用
cat test.py
import util
util.write_log('api').info('just a test')

import logging
# 成立一个logger
logger = logging.getLogger('mylogger')
logger.setLevel(logging.DEBUG)
# 制造一个handler,用于写入日志文件
fh = logging.FileHandler('test.log')
fh.setLevel(logging.DEBUG)
# 再次创下造三个handler,用于出口到调节台
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# 定义handler的出口格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 给logger添加handler
logger.addHandler(fh)
logger.addHandler(ch)
# 记录一条日志
logger.info('foorbar')

复制代码 代码如下:

  1. 自定义 Log 的输出格式

四: 关于root logger以及logger的老爹和儿子关系

logger实例之间还应该有老爹和儿子关系, root logger正是处于最顶层的logger, 它是兼具logger的古代人。如下图:
什么收获root logger
root logger是默许的logger假如不创建logger实例, 直接调用logging.debug()、logging.info()logging.warning(),logging.error()、logging.critical()那
些函数,
这正是说使用的logger就是 root logger, 它能够自行创设,也是单实例的。
root logger的日志等第
root logger默认的level是logging.WARNING
何以表示父亲和儿子关系
logger的name的命有名的模特式能够表示logger之间的父子关系. 比方:
parent_logger = logging.getLogger('foo')
child_logger = logging.getLogger('foo.bar')
什么是effective level
logger有一个概念,叫effective level。 要是多个logger未有体现地安装level,那么它就
用阿爹的level。即便阿爹也远非展现地设置level, 就用老爹的阿爹的level,以此推....
最后达到root logger,一定设置过level。默感觉logging.WARAV4NING
child loggers获得音信后,既把新闻分发给它的handler处理,也会传递给持有祖先logger管理,
eg:
import logging
# 设置root logger,祖先
r = logging.getLogger()
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
r.addHandler(ch)
# 创造三个logger作为老爹
p = logging.getLogger('foo')
p.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(message)s')
ch.setFormatter(formatter)
p.addHandler(ch)
# 创制三个子女logger
c = logging.getLogger('foo.bar')
c.debug('foo')
输出:
二零一一-08-31 21:04:29,893 - foo #老爹管理
二零一二-08-31 21:04:29,893 - DEBUG - foo #祖先管理
可见, 孩子logger从不另外handler,所以对音讯不做处理。不过它把信息转载给了它的爹爹以及root logger。最终输出两条日志。
那也就涌出了二个标题,同一条日志会重复输出
缓慢解决方案
1:每一种logger实例都给三个单身的名字,输出之间互不影响,
2: logging.conf中定义不三回九转

构成方面包车型地铁事例,我们说下多少个最常使用的API:
  logging.getLogger([name])
  重回贰个logger实例,若无一点名name,再次回到root logger。只要name同样,重回的logger实例都以同贰个同偶然候唯有一个,即name和logger实例是逐条对应的。那代表,无需把logger实例在相继模块中传送。只要明白name,就能够博取同一个logger实例。
  Logger.setLevel(lvl)
  设置logger的level, level有以下多少个等级:
    
  级别高低顺序:NOTSET < DEBUG < INFO < WA福特ExplorerNING < EENCORERO景逸SUV< C奥迪Q3ITICAL
  假若把looger的等级设置为INFO, 那么小于INFO级其他日志都不出口, 大于等于INFO品级的日记都输出  

import logging
import sys

透过format参数,能够定制写入log文件的格式。
 
 
import logging
logging.basicConfig(format='%(levelname)s:%(message)s',level=logging.DEBUG)
抑或更详细的利用以下措施,那也是自个儿常利用的办法:

复制代码代码如下:

LEVELS = {'debug': logging.DEBUG,
          'info': logging.INFO,
          'warning': logging.WARNING,
          'error': logging.ERROR,
          'critical': logging.CRITICAL}

logging.basicConfig(
        level=logging.DEBUG,
        format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S',
        filename=os.path.join(LOG_PATH, 'example.log'),
        filemode='a'
    )
出口格式如下所示:

logger.debug("foobar")    # 不输出   
logger.info("foobar")        # 输出  
logger.warning("foobar")  # 输出  
logger.error("foobar")      # 输出  
logger.critical("foobar")    # 输出  

if len(sys.argv) > 1:
    level_name = sys.argv[1]
    level = LEVELS.get(level_name, logging.NOTSET)
    logging.basicConfig(level=level)

2016-07-25 23:43:23 log.py[line:23] DEBUG This is debug level  

Logger.addHandler(hdlr)
透过handler对象足以把日记内容写到分裂的地点。比方简单的StreamHandler正是把日志写到类似文件的地点。python提供了十三种实用handler,相比常用有:

logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical error message')

  1. 从八个例外的模块中记录日志

复制代码代码如下:

输出:

logging 模块提供了一些更加结实大的组件用于在多个例外模块中著录日志,loggers, handlers, filters 和 formatters。

StreamHandler: 输出到调整台
 FileHandler:   输出到文件
BaseRotatingHandler 能够定时间写入到差异的日志中。比如将日志按天写入分裂的日子结尾的文书文件。
SocketHandler 用TCP网络连接写LOG
DatagramHandler 用UDP网络连接写LOG
SMTPHandler 把LOG写成EMAIL邮寄出来

复制代码 代码如下:

本文由江苏福彩快三发布,转载请注明来源

关键词: 江苏福彩快三