摘要：上一篇文章模塊分析第節模塊一日志記錄的級別優先級，記錄調試的詳細信息，只在調試時開啟優先級，記錄普通的消息，報告錯誤和警告等待。監聽端口號上一篇文章模塊分析第節模塊

上一篇文章：Python模塊分析：第3節-typing模塊

debug：優先級10，記錄調試的詳細信息，只在調試時開啟

info：優先級20，記錄普通的消息，報告錯誤和警告等待。

warning：優先級30，記錄相關的警告信息。

error：優先級40，記錄錯誤信息、程序崩潰

critical：優先級50，記錄錯誤信息

如果不設置，默認為iwarning

查看logging的源碼，可知主要有四個類實現功能：

Loggers：提供應該程序直接使用的接口，如相關的配置設置

Handlers：將Loggers產生的日志傳到指定位置，設置日志保存的位置；

Filters：對輸出日志進行過濾操作；

Formatters：控制日志的輸出格式

Formatters對象定義了日志的輸出格式，有多種可選參數。

實例：

import logging

#fmt:定義輸出的日志信息的格式
#datefmt：定義時間信息的格式，默認為：%Y-%m-%d %H:%M:%S
#style:定義格式化輸出的占位符，默認是%(name)格式，可選{}或$格式
formatter=logging.Formatter(fmt="%(asctime)s    %(levelname)s:  %(message)s"
                            ,datefmt="%Y-%m-%d %H:%M:%S",style="%")

日志處理器用來處理日志的具體流向，是輸出到文件中還是標準輸出等，它通過設置Formatter控制輸出格式，添加filters過濾日志。

常用的處理器有兩種

StreamHandler：用于向控制臺打印日志

FileHandler：用于向日志文件打印日志

其它的處理器

from logging import Handler

#所有日志處理器的父類
handler=Handler()

print("處理日志的等級：",handler.level)
print("處理日志的名字：",handler.name)
print("處理器的日志過濾器：：",handler.filters)
print("日志的格式：：",handler.filters)

#一些常用方法：
handler.get_name()
handler.set_name("")
handler.createLock()#創建線程鎖
handler.acquire()#獲取線程鎖
handler.release()#釋放線程鎖
handler.setLevel("info") #設置日志處理器的記錄級別
handler.setFormatter(fmt="")#設置日志的輸出格式
handler.addFilter("")#往處理器中添加過濾器
handler.removeFilter("")#往處理器中移除過濾器
handler.emit("")#日志記錄的處理邏輯，由子類實現

Logger管理著所有記錄日志的方法。

from logging import error, debug, warning, info, fatal, critical, getLogger

#返回一個Logger實例
#以"root"為名字的日志對象在Logger對象中只有一個實例
logger=getLogger("root")

print("獲取根日志對象",logger.root)
print("獲取manager",logger.manager)
print("獲取根日志對象的名字",logger.name)
print("獲取根日志對象記錄水平",logger.level)
print("獲取根日志對象過濾器列表",logger.filters)
print("獲取根日志對象處理器列表",logger.handlers)
print("獲取根日志對象",logger.disabled)

#設置日志記錄水平
logger.setLevel("info")

#輸出日志信息，格式化輸出
logger.info("this is %s","info",exc_info=1)
#記錄warning信息
logger.warning("")
#記錄error信息
logger.error("")
#等價于logger.error("",exc_info=1)
logger.exception("")
#記錄debug信息
logger.debug("")
#記錄critical信息
logger.critical("")
#直接指定級別
logger.log("info","")

#添加處理器
logger.addHandler()
#移除處理器
logger.removeHandler()
#判是否有處理器
logger.hasHandlers()

實例：

import logging
import sys

def my_get_logger(appname):
    #獲取logger實例，如果參數為空則返回root logger
    logger=logging.getLogger(appname)
    #創建日志輸出格式
    formatter=logging.Formatter("%(asctime)s    %(levelname)s   %(mark)s:  %(message)s")

    #指定輸出的文件路徑
    file_handler=logging.FileHandler("test.log")
    # 設置文件處理器，加載處理器格式
    file_handler.setFormatter(formatter)

    #控制臺日志
    console_handler=logging.StreamHandler(sys.stdout)
    console_handler.formatter=formatter

    #為logger添加的日志處理器
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)

    #指定日志的最低輸出級別，默認為warn級別
    logger.setLevel(logging.INFO)
    return logger

if __name__ == "__main__":
    logger=my_get_logger("test")
    # extra： 這是一個字典（dict）參數，它可以用來自定義消息格式中所包含的字段，但是它的key不能與logging模塊定義的字段沖突。
    logger.debug("this is debug info",extra={"mark":"mark"})
    logger.info("this is information",extra={"mark":"mark"})
    logger.warning("this is warning message",extra={"mark":"mark"})
    logger.error("this is error message",extra={"mark":"mark"})
    logger.fatal("this is fatal message,it is same ad logger.critical",extra={"mark":"mark"})
    logger.critical("this is critical message",extra={"mark":"mark"})

結果：

2018-11-27 09:54:43,318    INFO   mark:  this is information
2018-11-27 09:54:43,318    WARNING   mark:  this is warning message
2018-11-27 09:54:43,318    ERROR   mark:  this is error message
2018-11-27 09:54:43,319    CRITICAL   mark:  this is fatal message,it is same ad logger.critical
2018-11-27 09:54:43,319    CRITICAL   mark:  this is critical message

記錄日志通過調用logger.debug等方法；

首先判斷本條記錄的日志級別是否大于設置的級別，如果不是，直接pass，不再執行；

將日志信息當做參數創建一個LogRecord日志記錄對象

將LogRecord對象經過logger過濾器過濾，如果被過濾則pass

日志記錄對象被Handler處理器的過濾器過濾

判斷本條記錄的日志級別是否大于Handler處理器設置的級別，如果不是，直接pass，不再執行；

最后調用處理器的emit方法處理日志記錄；

通過代碼進行完整配置，主要是通過getLogger方法實現，但不好修改

通過basicConfig方法實現，這種方式快速但不夠層次分明

通過logging.config.fileConfig(filepath)，文件配置

通過dictConfig的字典方式配置，這是py3.2版本引入的新的配置方法

#logging.cong

[loggers]
#定義日志的對象名稱是什么，注意必須定義root，否則報錯
keys=root,main

[handlers]
#定義處理器的名字是什么，可以有多個，用逗號隔開
keys=consoleHandler

[formatters]
#定義輸出格式對象的名字，可以有多個，用逗號隔開
keys=simpleFormatter

[logger_root]
#配置root對象的日志記錄級別和使用的處理器
level=INFO
handlers=consoleHandler

[logger_main]
#配置main對象的日志記錄級別和使用的處理器，qualname值得就是日志對象的名字
level=INFO
handlers=consoleHandler
qualname=main
#logger對象把日志傳遞給所有相關的handler的時候，會逐級向上尋找這個logger和它所有的父logger的全部handler，
#propagate=1表示會繼續向上搜尋；
#propagate=0表示停止搜尋，這個參數涉及重復打印的坑。
propagate=0

[handler_consoleHandler]
#配置處理器consoleHandler
class=StreamHandler
level=WARNING
formatter=simpleFormatter
args=(sys,)

[formatter_simpleFormatter]
#配置輸出格式過濾器simpleFormatter
format=%(asctime)-%(name)s-%(levelname)s-%(message)s

注意：可以看到logger和Handler都可以設置日志級別，日志輸出是取最高級別。

字典形式配置功能更強大，也更加靈活。通過dictConfig函數，我們可以將其他格式的配置文件轉化成字典，如json，YAML等。

實例：

import yaml
from logging.config import dictConfig
import os
filename=os.path.dirname(os.path.abspath(__file__))
with  open(filename+"/logging.yaml","r") as f:
    log=yaml.load(f.read())
    dictConfig(log)

#logging.yaml
#注意：yaml格式嚴格，:后面一定要帶空格
version: 1
formatters:
    simple:
          format: "%(asctime)s-%(name)s-%(levelname)s-%(message)s"
handlers:
    console:
          class: logging.StreamHandler
          level: DEBUG
          formatter: simple
          stream: ext://sys.stdout
    console_err:
          class: logging.StreamHandler
          level: DEBUG
          formatter: simple
          stream: ext://sys.stderr
loggers:
    simpleExample:
          level: DEBUG
          handlers: [console]
          propagate: no
root:
    level: DEBUG
    handlers: [console_err]]

logging.config.listen(port)函數可以讓英語程序在一個socket上監聽新的配置信息，達到在運行時改變配置，而不用重啟應用程序的目的。

import logging.config
import logging
logging.config.fileConfig("logging.conf")
logger=logging.getLogger("test.listen")

#監聽端口號9999
t=logging.config.listen(9999)
t.setDaemon(True)
t.start()

上一篇文章：Python模塊分析：第3節-typing模塊