Python logging用法总结

import logging
from logging.handlers import RotatingFileHandler
import subModule
import json
import logging.config
import os

"""
    logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；
    
    相比print，具备如下优点：
        1.可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
        2.print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；
        3.logging则可以由开发者决定将信息输出到什么地方，以及怎么输出；
        
    logging中可以选择很多消息级别，如debug、info、warning、error以及critical。
    
    通过赋予logger或者handler不同的级别，开发者就可以只输出错误信息到特定的记录文件，或者在调试时只记录调试信息。
    
    logging.basicConfig函数各参数：
        filename：指定日志文件名；
        filemode：和file函数意义相同，指定日志文件的打开模式，'w'或者'a'；
        format：指定输出的格式和内容，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：打印日志信息
        datefmt：指定时间格式，同time.strftime()；
        level：设置日志级别，默认为logging.WARNNING；
        stream：指定将日志的输出流：
            可以指定输出到sys.stderr，sys.stdout或者文件；
            默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略；
            
    日志等级：
        FATAL：致命错误
        CRITICAL：特别糟糕的事情，如内存耗尽、磁盘空间为空，一般很少使用
        ERROR：发生错误时，如IO操作失败或者连接问题
        WARNING：发生很重要的事件，但是并不是错误时，如用户登录密码错误
        INFO：处理请求或者状态变化等日常事务
        DEBUG：调试过程中使用DEBUG等级，如算法中每个循环的中间状态
            
    logging有一个日志处理的主对象，其他处理方式都是通过addHandler添加进去，logging中包含的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服务器
"""

Handler_mode = 1 # 根据执行需要修改

"""基本使用开始"""
if Handler_mode == 1:
    # 可以先进行一下基础配置，不用这个函数配置也行，可以用logger.setLevel(level = logging.INFO)代替
    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # 如果模块是被导入‘__name__’的值为模块名字（不带.py），如果模块是被直接执行‘__name__’的值为’__main__’
    logger = logging.getLogger(__name__)  # 定义一个logger对象，给这个对象起个名字，这里用__name__(也就是__main__)命名

    logger.info("Start print log")
    logger.debug("Do something")
    logger.warning("Something maybe fail.")
    logger.info("Finish")
"""基本使用结束"""

"""将日志写入到文件开始"""
if Handler_mode == 2:
    # 这两行定义logger对象
    logger = logging.getLogger(__name__)
    logger.setLevel(level=logging.DEBUG)
    # 这两行定义文件处理handler对象
    handler = logging.FileHandler("log.txt")
    handler.setLevel(logging.DEBUG)
    # 定义一个logging格式对象
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # 给文件处理对象设定格式
    handler.setFormatter(formatter)
    # 给logger对象添加文件处理操作
    logger.addHandler(handler)

    # 把信息送到文件处理handler对象中，不会在屏幕上打印，stream被忽略掉了
    logger.info("Start print log")  # 相当于一个输出语句，括号内是输出信息，这里把信息输出到了handler中
    logger.debug("Do something")
    logger.warning("Something maybe fail.")
    logger.info("Finish")
"""将日志写入到文件结束"""

"""将日志同时输出到屏幕和日志文件开始"""
if Handler_mode == 3:
    logger = logging.getLogger(__name__)
    logger.setLevel(level=logging.INFO)
    handler = logging.FileHandler("log.txt")
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)

    logger.addHandler(handler)
    logger.addHandler(console)

    logger.info("Start print log")
    logger.debug("Do something")
    logger.warning("Something maybe fail.")
    logger.info("Finish")
"""将日志同时输出到屏幕和日志文件结束"""

"""使用RotatingFileHandler，可以实现日志回滚开始"""
"""
    什么是日志回滚？
        将日志信息输出到一个单一的文件中，随着应用程序的持续使用，该日志文件会越来越庞大，进而影响系统的性能。
    因此，有必要对日志文件按某种条件进行切分，要切分日志文件。分割日志的触发条件：大小、日期，或者大小加上日期。
    说是切分，实际上是，当一个日志文件达到触发条件后，对日志文件进行重命名，之后再新建原来名称的日志文件（此时就是空文件了），
    新产生的日志就写入新的日志文件。为啥叫回滚呢？当分割的日志文件达到指定数目的上限个数时，最老的日志文件就会被删除。
    logging库提供了两个可以用于日志滚动的class，一个是RotatingFileHandler，它主要是根据日志文件的大小进行滚动，
    另一个是TimeRotatingFileHandler，它主要是根据时间进行滚动。在实际应用中，我们通常根据时间进行滚动。
"""
if Handler_mode == 4:
    logger = logging.getLogger(__name__)
    logger.setLevel(level=logging.INFO)
    # 定义一个RotatingFileHandler，最多备份3个日志文件，每个日志文件最大1K
    rHandler = RotatingFileHandler("log.txt", maxBytes=1 * 1024, backupCount=3)
    rHandler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    rHandler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(formatter)

    logger.addHandler(rHandler)
    logger.addHandler(console)

    logger.info("Start print log")
    logger.debug("Do something")
    logger.warning("Something maybe fail.")
    logger.info("Finish")
"""使用RotatingFileHandler，可以实现日志回滚结束"""

"""捕获traceback开始"""
if Handler_mode == 5:
    logger = logging.getLogger(__name__)
    logger.setLevel(level=logging.INFO)
    handler = logging.FileHandler("log.txt")
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)

    logger.addHandler(handler)
    logger.addHandler(console)

    logger.info("Start print log")
    logger.debug("Do something")
    logger.warning("Something maybe fail.")
    try:
        open("sklearn.txt", "rb")
    except (SystemExit, KeyboardInterrupt):
        raise
    except Exception:
        # Python中的traceback模块被用于跟踪异常返回信息，可以在logging中记录下traceback(如下exc_info)
        # 可以用logger.exception("Failed to open sklearn.txt from logger.exception")替换以下代码
        logger.error("Faild to open sklearn.txt from logger.error", exc_info=True)

    logger.info("Finish")
"""捕获traceback结束"""

"""多模块使用logging开始"""
"""
    如果要跑程序的话，用这段代码新建一个py文件
        module_logger = logging.getLogger("mainModule.sub")
    
        class SubModuleClass(object):
            def __init__(self):
                self.logger = logging.getLogger("mainModule.sub.module")
                self.logger.info("creating an instance in SubModuleClass")
    
            def doSomething(self):
                self.logger.info("do something in SubModule")
                a = []
                a.append(1)
                self.logger.debug("list a = " + str(a))
                self.logger.info("finish something in SubModuleClass")
    
        def som_function():
            module_logger.info("call function some_function")
"""
if Handler_mode == 6:
    logger = logging.getLogger("mainModule")
    logger.setLevel(level=logging.INFO)
    handler = logging.FileHandler("log.txt")
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(formatter)

    logger.addHandler(handler)
    logger.addHandler(console)

    logger.info("creating an instance of subModule.subModuleClass")
    a = subModule.SubModuleClass()
    logger.info("calling subModule.subModuleClass.doSomething")
    a.doSomething()
    logger.info("done with  subModule.subModuleClass.doSomething")
    logger.info("calling subModule.some_function")
    subModule.som_function()
    logger.info("done with subModule.some_function")
"""
    首先在主模块定义了logger'mainModule'，并对它进行了配置，
    就可以在解释器进程里面的其他地方通过getLogger('mainModule')得到的对象都是一样的，
    不需要重新配置，可以直接使用。定义的该logger的子logger，都可以共享父logger的定义和配置，
    所谓的父子logger是通过命名来识别，任意以'mainModule'开头的logger都是它的子logger，例如'mainModule.sub'。
    实际开发一个application，首先可以通过logging配置文件编写好这个application所对应的配置，
    可以生成一个根logger，如'PythonAPP'，然后在主函数中通过fileConfig加载logging配置，
    接着在application的其他地方、不同的模块中，可以使用根logger的子logger，
    如'PythonAPP.Core'，'PythonAPP.Web'来进行log，而不需要反复的定义和配置各个模块的logger。
"""
"""多模块使用logging结束"""

"""通过JSON文件配置开始"""
if Handler_mode == 7:
    def setup_logging(default_path="logging.json", default_level=logging.INFO, env_key="LOG_CFG"):
        path = default_path
        value = os.getenv(env_key, None)
        if value:
            path = value
        if os.path.exists(path):
            with open(path, "r") as f:
                config = json.load(f)
                logging.config.dictConfig(config)
        else:
            logging.basicConfig(level=default_level)


    def func():
        logging.info("start func")
        logging.info("exec func")
        logging.info("end func")


    setup_logging(default_path="logging.json")
    func()
"""通过JSON文件配置结束"""

           

参考地址：https://www.cnblogs.com/liujiacai/p/7804848.html