作为一个算法工程师（咳咳），还是需要了解基本的python日志，来为自己的项目构建日志系统的。日志的功能主要是可以方便统计访问信息；方便排查错误，当错误发生的时候，可以在不中断服务器的情况下，直接查看抛出异常的追踪信息，不会影响其他征程的访问；在平时的代码开发过程中，日志实现dubug以及追踪的基本环境，告诉我们现在执行到哪一步了，每一步的结果是什么。

Python的logging模块提供了通用的日志系统，可以方便第三方模块或者是应用使用。

我按照自己学习的习惯，首先介绍简单的背景，然后是整个日志调用代码生成的逻辑，接着是需要记住（记不是可能记住，毕竟一个项目也就写一遍日志系统，方便自己查阅）的常用函数和常用接口，最后添加了几个实际案例。

logging模块提供logger，handler，filter，formatter四个构建：（下面这段分类来自[# python接口自动化（三十九）- logger 日志 - 上)

1. logger提供日志接口，供应用代码使用。
   logger最长用的操作有两类：配置和发送日志消息。可以通过logging.getLogger(name)获取logger对象，如果不指定name则返回root对象，多次使用相同的name调用getLogger方法返回同一个logger对象。
2. handler
   将日志记录（log record）发送到合适的目的地（destination）,比如文件，socket等。一个logger对象可以通过addHandler方法添加0到多个handler，每个handler又可以定义不同日志级别，以实现日志分级过滤显示。
3. filter
   提供一种优雅的方式决定一个日志记录是否发送到handler。
4. formatter
   指定日志记录输出的具体格式。formatter的构造方法需要两个参数：消息的格式字符串和日期字符串，这两个参数都是可选的。

总的一个逻辑是这样的，我们需要创建一个logger,这样在代码执行中，可以使用logger.debug/info/warning/error等方法，将日志输出到指定的位置（可以是控制台、文件，可多选）；创建logger之后，需要给logger添加处理句柄handler,每个句柄就对应一种输出，比如StreamHandler表示输出到控制台（当然我这里简单化了），FileHandler输出到指定文件。然后给句柄设置格式Format，这就是你想要看见的格式，比如%(asctime)s %(threadName)s @%(filename)s:%(lineno)d%(message)s表示首先是日期，然后是对应线程名称，日志来自的文件名称，来自哪一行，最后是需要输出的日志信息。
上面这种形式的输出为

11-19 14:28:00 Thread-2 @image_alignment.py:233  run success

调用简图

logging中可以选择很多消息级别，如debug、info、warning、error以及critical。通过赋予logger或者handler不同的级别，开发者就可以只输出错误信息到特定的记录文件，或者在调试时只记录调试信息。
在设置logger的时候，不同的logger级别决定了输出的信息，如果定义level=info,则不会输出debug信息。

接口的具体使用

1. logger的定义

Logging.Logger：Logger是Logging模块的主体，进行以下三项工作：

1. 为程序提供记录日志的接口
2. 判断日志所处级别，并判断是否要过滤
3. 根据其日志级别将该条日志分发给不同handler
   常用函数有：
   Logger.setLevel()设置日志级别
   Logger.addHandler() 和Logger.removeHandler()添加和删除一个Handler
   Logger.addFilter()添加一个Filter,过滤作用

2. handler的使用

所有的handler汇总，按需自取

StreamHandler：logging.StreamHandler；日志输出到流，可以是sys.stderr，sys.stdout或者文件
FileHandler：logging.FileHandler；日志输出到文件
BaseRotatingHandler：logging.handlers.BaseRotatingHandler；基本的日志回滚方式
RotatingHandler：logging.handlers.RotatingHandler；日志回滚方式，支持日志文件最大数量和日志文件回滚
TimeRotatingHandler：logging.handlers.TimeRotatingHandler；日志回滚方式，在一定时间区域内回滚日志文件
SocketHandler：logging.handlers.SocketHandler；远程输出日志到TCP/IP sockets
DatagramHandler：logging.handlers.DatagramHandler；远程输出日志到UDP sockets
SMTPHandler：logging.handlers.SMTPHandler；远程输出日志到邮件地址
SysLogHandler：logging.handlers.SysLogHandler；日志输出到syslog
NTEventLogHandler：logging.handlers.NTEventLogHandler；远程输出日志到Windows NT/2000/XP的事件日志
MemoryHandler：logging.handlers.MemoryHandler；日志输出到内存中的指定buffer
HTTPHandler：logging.handlers.HTTPHandler；通过"GET"或者"POST"远程输出到HTTP服务器

经常使用的有
StreamHandler用于输出到控制台等标准输出
stream：指定将日志的输出流，可以指定输出到sys.stderr，sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略；

RotatingHandler日志回滚
举个例子：
rHandler = RoratingHandler("log.txt",maxBytes=1*1024,backupCount=3)#备份为3，每个日志文件大小为1K。
其实意思就是log会写在一个文件，这个文件定义成1K大小，日志太多写不下的话，它会自动备份成log.txt.1,log.txt.2 ......，然后再创建一个log.txt开始写log。

TimedRotatingFileHandler 时间日志回滚
举个例子：
log_file_handler = TimedRotatingFileHandler(filename="ds_update", when="M", interval=2, backupCount=2)
filename：日志文件名的prefix；when：是一个字符串，用于描述滚动周期的基本单位，字符串的值及意义如下： “S”: Seconds “M”: Minutes “H”: Hours “D”: Days “W”: Week day (0=Monday) “midnight”: Roll over at midnight
interval: 滚动周期，单位有when指定，比如：when=’D’,interval=1，表示每天产生一个日志文件
backupCount: 表示日志文件的保留个数

FileHandler：文件日志
有两个参数filename：指定日志文件名；
filemode：和file函数意义相同，指定日志文件的打开模式，'w'或者'a'；

3. Formater的使用

format：指定输出的格式和内容，format可以输出很多有用的信息

参数：作用
%(levelno)s：打印日志级别的数值
%(levelname)s：打印日志级别的名称
%(pathname)s：打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(asctime)s：打印日志的时间
%(thread)d：打印线程ID
%(threadName)s：打印线程名称
%(process)d：打印进程ID
%(message)s：打印日志信息

举个例子

console_fmt = '%(asctime)-15s [%(TASK)s] %(message)s'
    console_formatter = logging.Formatter(console_fmt)

除了简单的设置，还可以设置更加复杂的格式，比如在控制台上设置不同级别的日志信息使用不同的颜色，那么可以定义个formmter类,然后在setFormatter()函数中添加这个类的实例。

import logging
class _Formatter(logging.Formatter):
    def format(self, record):
        msg = '%(message)s'
        if record.levelno == logging.WARNING:
            date = colored(
                '[%(asctime)s %(threadName)s @%(filename)s:%(lineno)d]',
                'yellow')
            fmt = date + ' ' + colored(
                'WRN', 'yellow', attrs=['blink']) + ' ' + msg
        elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
            date = colored(
                '[%(asctime)s %(threadName)s @%(filename)s:%(lineno)d]', 'red')
            fmt = date + ' ' + colored(
                'WRN', 'yellow', attrs=['blink']) + ' ' + msg
            fmt = date + ' ' + colored(
                'ERR', 'red', attrs=['blink', 'underline']) + ' ' + msg
        elif record.levelno == logging.DEBUG:
            date = colored(
                '[%(asctime)s %(threadName)s @%(filename)s:%(lineno)d]',
                'blue')
            fmt = date + ' ' + colored(
                'DEBUG', 'blue', attrs=['blink']) + ' ' + msg
        else:
            date = colored(
                '[%(asctime)s %(threadName)s @%(filename)s:%(lineno)d]',
                'green')
            fmt = date + ' ' + msg
        if hasattr(self, '_style'):
            # Python3 compatibility
            self._style._fmt = fmt
        self._fmt = fmt
        return super(_Formatter, self).format(record)
        
general_logger = logging.getLogger('general')
general_logger.setLevel(logging.DEBUG)
# 标准输出的handler
std_handler = logging.StreamHandler(sys.stdout)
std_handler.setLevel(std_log_level)
std_handler.setFormatter(_Formatter(datefmt='%m-%d %H:%M:%S'))

4. Level级别

level：设置日志级别，默认为logging.WARNNING；
可以给logger和handler设置不同的级别，比如logger设置为debug，然后handler1设置为error,这样这个输出只会记录error以上的日志级别信息，另一个handler2设置为info,记录info级别以上的信息。有下面这几种可以设置

日志等级：使用范围

FATAL：致命错误
CRITICAL：特别糟糕的事情，如内存耗尽、磁盘空间为空，一般很少使用
ERROR：发生错误时，如IO操作失败或者连接问题
WARNING：发生很重要的事件，但是并不是错误时，如用户登录密码错误
INFO：处理请求或者状态变化等日常事务
DEBUG：调试过程中使用DEBUG等级，如算法中每个循环的中间状态
NOTSET：如果设置了日志级别为NOTSET,那么这里可以采取debug、info的级别的内容也可以显示在控制台上了

5. 日志的使用

一个项目不会只有一个文件的代码，一般都会把logger的设置单独保存为一个py文件，在执行主入口的时候，执行其中的logger生成函数，然后这个logger就会记录在内存中，在其他的代码中，只要在前面添加

import loggging
logger  = logging.getLogger("my_log")

就可以轻松的使用了。
常见的记录有

logger.debug/info/warning/error/critical/fatal(msg)# 分别记录不同的日志级别信息

当需要输出追踪异常返回信息的traceback时，可以这样设置
logger.error("文字简单描述“，exc_info=True)或者是logger.exception("Failed to open sklearn.txt from logger.exception")

实际使用案例

案例一：log的定义和使用在一个文件中使用

import logging  # 引入logging模块
import os.path
import time
# 第一步，创建一个logger，如果不命名，则默认命名
# 这里的定义和以后在别的文件中使用logger的获取方式是一致的，都是下面这个语句

logger = logging.getLogger('general')
logger.setLevel(logging.INFO)  # Log等级总开关
# 第二步，创建一个handler，用于写入日志文件
rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
log_path = os.path.dirname(os.getcwd()) + '/Logs/'
log_name = log_path + rq + '.log'
logfile = log_name
fh = logging.FileHandler(logfile, mode='w')
fh.setLevel(logging.DEBUG)  # 输出到file的log等级的开关
# 第三步，定义handler的输出格式
formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
fh.setFormatter(formatter)
# 第四步，将logger添加到handler里面
logger.addHandler(fh)
# 日志
logger.debug('this is a logger debug message')
logger.info('this is a logger info message')
logger.warning('this is a logger warning message')
logger.error('this is a logger error message')
logger.critical('this is a logger critical message')

案例二： 一个logger,多个handler

import errno
import logging
import os
import os.path
import sys
from termcolor import colored
from logging.handlers import TimedRotatingFileHandler

std_log_level = logging.INFO
path = "./log/"
def create_log():
    path = LOG_PATH
    general_logger = logging.getLogger('general')
    general_logger.setLevel(logging.DEBUG)
    # 标准输出的handler
    std_handler = logging.StreamHandler(sys.stdout)
    std_handler.setLevel(
def create_log():
    path = LOG_PATH
    general_logger = logging.getLogger('general')
    general_logger.setLevel(logging.DEBUG)
    # 标准输出的handler
    std_handler = logging.StreamHandler(sys.stdout)
    std_handler.setLevel(std_log_level)
    std_handler.setFormatter(_Formatter(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(std_handler)

    # 全部日志输出general_handler
    general_path = os.path.join(path, "general.log")
    general_handler = TimedRotatingFileHandler(general_path,when='D',interval=1,backupCount=100)
    general_handler.setLevel(logging.DEBUG)
    general_handler.setFormatter(_Formatter_text(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(general_handler)

    # 错误日志输出error_handler
    error_path = os.path.join(path,"error.log")
    error_handler = TimedRotatingFileHandler(error_path,when='D',interval=1,backupCount=100)
    error_handler.setLevel(logging.ERROR)
    error_handler.setFormatter(_Formatter_text(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(error_handler)

create_log()
    std_handler.setFormatter(_Formatter(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(std_handler)

    # 全部日志输出general_handler
    general_path = os.path.join(path, "general.log")
    general_handler = TimedRotatingFileHandler(general_path,when='D',interval=1,backupCount=100)
    general_handler.setLevel(logging.DEBUG)
    general_handler.setFormatter(_Formatter_text(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(general_handler)

    # 错误日志输出error_handler
    error_path = os.path.join(path,"error.log")
    error_handler = TimedRotatingFileHandler(error_path,when='D',interval=1,backupCount=100)
    error_handler.setLevel(logging.ERROR)
    error_handler.setFormatter(_Formatter_text(datefmt='%m-%d %H:%M:%S'))
    general_logger.addHandler(error_handler)

create_log() # 注意一定要有这一句，否则不会执行logger的生成。不可以

案例三： 接着上面的案例，在不同的代码文件中调用这个logger

1. 首先在最先执行的代码中，加载上面的这个ms_logger.py代码

import ms_logger.py # 这一步之后，该logger就会保存在内存中

2. 在其他的代码中添加

import logging
logger = logging.getLogger("general")

...

logger.info(”执行代码成功”）
...

非常的简单方便

参考资料

python接口自动化（三十九）- logger 日志 - 上
python接口自动化（四十）- logger 日志 - 下
python中logging日志模块详解
【python logging】自定义日志过滤器，通过参数控制日志记录