簡單使用
最開始，我們用最短的代碼體驗一下logging的基本功能。
import logging
logger = logging.getLogger()
logging.basicConfig()
logger.setLevel('DEBUG')
logger.debug('logsomething')
#輸出
out>>DEBG:root:logsomething
第一步，通過logging.getLogger函數(shù)，獲取一個loger對象，但這個對象暫時是無法使用的。
第二步，logging.basicConfig函數(shù)，進行一系列默認的配置，包括format、handler等。
第三步，logger調用setLevel函數(shù)定義日志級別為DEBUG 最后，調用debug函數(shù)，輸出一條debug級別的message，顯示在了標準輸出上。 logging中的日志級別
logging在生成日志的時候，有一個日志級別的機制，默認有以下幾個日志級別：
CRITICAL = 50
ERROR = 40
WARNING = 30
INFO 20
DEBUG = 10
NOTEST = 0
每一個logger對象，都有一個日志級別，它只會輸出高于它level的日志。如果一個logger的level是INFO，那么調用logger.debug()是無法輸出日志的，而logger.warning()能夠輸出。
一般來說，以上的6個日志級別完全滿足我們日常使用了。
logging中的基礎類
logging是python的一個基礎模塊，它在python中的源碼位置如下：
#主干代碼
/usr/lib/python2.7/logging/__init__.py
#擴展的handler和config
/usr/lib/pyhon2.7/logging/config.py
/usr/lib/python2.7/loging/handlers.py
組成logging的主干的幾個基礎類都在__init__.py中：
第一個基礎類LogRecord
一個LogRecord對象，對應了日志中的一行數(shù)據(jù)。通常包含：時間、日志級別、message信息、當前執(zhí)行的模塊、行號、函數(shù)名...這些信息都包含在一個LogRecord對象里。
LogRecord對象可以想象成一個大字典：
class LogRecord(object):
#代表一條日志的類
def getMessage(self):
#獲取self.msg
def markLogRecord(dict):
#這個方法很重要，生成一個空的LogRecord，然后通過一個字典，直接更新LogReocrd中的成員變量
rv = LogRecord(None, None, "", 0, "", (), None, None)
rv.__dict__.update(dict)
return rv
第二個基礎類Formatter
Formatter對象是用來定義日志格式的，LogRecord保存了很多信息，但是打印日志的時候我們只需要其中幾個，F(xiàn)ormatter就提供了這樣的功能，它依賴于python的一個功能：
#通過字典的方式，輸出格式化字符串
print('%(name)s:%(num)d'%{'name':'my_name', 'num' : 100})
out >>>my_name:100
重要的代碼如下：
class Formatter(object):
def __init__(self, fmt=None, datefmt = None):
if fmt:
self._fmt = fmt
else:
#默認的format
self._fmt = "%(message)s"
def format(self, record)
#使用self._fmt進行格式化
s = self._fmt %record.__dict__
return s
第三個基礎類Filter和Filterer
Filter類，功能很簡單。Filter.filter()函數(shù)傳入一個LogRecord對象，通過篩選返回1，否則返回0.從代碼中可以看到，其實是對LogRecord.name的篩選。
Filterer類中有一個Filter對象的列表，它是一組Filter的抽象。
重要的代碼如下：
class Filter(object):
def __init__(self, name=''):
self.name = name
self.nlen = len(name)
def filter(self, record):
#返回1表示record通過，0表示record不通過
if self.nlen == 0:
return 1
elif self.name == record.name:
return 1
#record.name不是以filter開頭
elif record.name.find(self.name, 0, self.nlen) != 0:
return 0
#最后一位是否為
return (record.name[self.nlen] == '.')
class Filterer(object):
#這個類其實是定義了一個self.filters = []的列表管理多個filter
def addFilter(self, filter):
def removefilter(self, filter):
def filter(self, record):
#使用列表中所有的filter進行篩選，任何一個失敗都會返回0
#例如：
#filter.name = 'A', filter2.name='A.B', filter2.name = 'A, B, C'
#此時record.name = 'A,B,C,D'這樣的record才能通過所有filter的篩選
logging中的高級類
有了以上三個基礎的類，就可以拼湊一些更重要的高級類了，高級類可以實現(xiàn)logging的重要功能。
Handler――抽象了log的輸出過程 Handler類繼承自Filterer。Handler類時log輸出這個過程的抽象。
同時Handler類具有一個成員變量self.level,在第二節(jié)討論的日志級別的機制，就是在Handler中實現(xiàn)的。
Handler有一個emit(record)函數(shù)，這個函數(shù)負責輸出log，必須在Handler的子類中實現(xiàn)。
重要代碼如下：
class Handler(Filterer):
def __init__(self, level = NOTEST)
#handler必須有l(wèi)evel屬性
self.level = _checkLevel(level)
def format(self, record):
#使用self.formatter, formattercord
def handler(self, record):
#如果通過filter的篩選，則emit這條log
rv = self.filter(record)
self.emit(record)
def emit(self, record):
#等待子類去實現(xiàn)
接下來看兩個簡單的handler的子類，其中在logging源碼中，有一個handler.py專門定義了很多復雜的handler，有的可以將log緩存在內存中，有的可以將log做rotation等。
StreamHandler
最簡單的handler實現(xiàn)，將log寫入一個流，默認的stream是sys.stderr
重要的代碼如下：
class StreamHandler(Handler):
def __init__(self, stream = None):
if stream is None:
stream = sys.stderr
self.stream = stream
def emit(self, record):
#將record的信息寫入流
#處理一些編碼的異常
fs = '%s\n' #每條日志都有換行
stream = self.stream
stream.write(fs%msg)
FileHandler
將log輸出到文件的handler，繼承StreamHandler
重要代碼如下：
class FileHandler(StreamHandler):
def __init__(self, filename, mode='a')
#append方式打開一個文件
StreamHandler.__init__(self, self._open())
def emit(self, record):
#和streamhandler保持一致
StreamHandler.emit(self, record)
Logger――一個獨立的log管道
什么是logger?
+ logger類繼承自Filterer,
+ logger對象有l(wèi)ogger.level日志級別
+ logger對象控制多個handler:logger.handlers = []
+ logger對象之間存在福字關系
簡單的來說，logger這個類，集中了我們以上所有的LogRecord、Filter類、Formatter類、handler類。首先，logger根據(jù)輸入生成一個LogRecord讀寫，經過Filter和Formatter之后，再通過self.handlers列表中的所有handler,把log發(fā)送出去。
一個logger中可能有多個handler，可以實現(xiàn)把一份log放到任意的位置。
class Logger(Filterer):
def __init__(self, name, level=NOTEST)
#handler列表
self.handlers = []
self.level = _checklevel(level)
def addHandler(self, hdlr):
def removeHandler(self, hdlr):
def _log(self, level, msg, args, exc_info=None, extra=None):
#在_log函數(shù)中創(chuàng)建了一個LogRecord對象
record = self.makeRecord(self.name, level, fn, lno, msg, args, exc_info, func, extra)
#交給handle函數(shù)
self.handle(record)
def handle(self, reord):
#進行filter,然后調用callHandlers
if(not self.disabled) and self.filter(record):
self.callHandlers(record)
def callHandlers(self, record):
#從當前l(fā)ogger到所有的父logger,遞歸的handl傳入的record
c = self
while c:
for hdlr in c.handlers:
hdlr.handle(record) #進入handler的emit函數(shù)發(fā)送log
....
c = c.parent
LoggerAdapter――對標準logger的一個擴展
LogRecord這個大字典中提供的成員變量已經很多，但是，如果在輸出log時候仍然希望能夠夾帶一些自己想要看到的更多信息，例如產生這個log的時候，調用某些函數(shù)去獲得其他信息，那么就可以把這些添加到Logger中，LoggerAdapter這個類就起到這個作用。
LoggerAdapter這個類很有意思，如果不做什么改動，那么LoggerAdapter類和Logger并沒有什么區(qū)別。LoggerAdapter只是對Logger類進行了一下包裝。
LoggerAdapter的用法其實是在它的成員函數(shù)process()的注釋中已經說明了：
def process(self, msg, kwargs):
'''
Normally,you'll only need to overwrite this one method in a LoggerAdapter subclass for your specific needs.
'''
也就是說重寫process函數(shù)，以下是一個例子：
import logging
import random
L=logging.getLogger('name')
#定義一個函數(shù)，生成0~1000的隨機數(shù)
def func():
return random.randint(1,1000)
class myLogger(logging.LoggerAdapter):
#繼承LoggerAdapter，重寫process，生成隨機數(shù)添加到msg前面
def process(self,msg,kwargs):
return '(%d),%s' % (self.extra['name'](),msg) ,kwargs
#函數(shù)對象放入字典中傳入
LA=myLogger(L,{'name':func})
#now,do some logging
LA.debug('some_loging_messsage')
out>>DEBUG:name:(167),some_loging_messsage
更多文章、技術交流、商務合作、聯(lián)系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯(lián)系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
