一、logging模块四大组件类

• 日志器Logger：提供程序一直使用的接口；
• 处理器Handler：将日志器创建的日志记录输出到指定位置，不同的处理器可将日志输出到不同的位置；
• 过滤器Filter：过滤日志，输出哪条日志记录，丢弃哪条日志记录；
• 格式器Formatter：日志记录的最终输出格式；

详细操作描述：日志器作为入口，通过设置多个处理器的方式将日志输出，处理器再通过过滤器和格式器对日志进行处理操作。
（1） Logger是以 （.）分割的层级结构，每个 . 前面的logger是后面logger的parent；
（2）一个Logger可以包含多个Handler；
（3）每个Handler可以设置自己的Filter和Formatter；

二、 Logger对象

1. Logger对象方法

（1）Logger对象的配置方法

• Logger.setLevel(level)：设置Logger对象日志消息级别
• Logger.addHandler(hdlr)：为Logger对象添加handler对象
• Logger.removeHandler(hdlr)：为Logger对象移除handler对象
• Logger.hasHandlers()：判断是否有处理器
• Logger.addFilter(filter)：为Logger对象添加filter对象
• Logger.removeFilter(filter)：为Logger对象移除filter对象

（2）Logger对象创建日志记录

• Logger.debug(msg, *args, **kwargs)：创建一个与方法名等级相同为debug的日志记录
• Logger.info(msg, *args, **kwargs)：创建一个与方法名等级相同为info的日志记录
• Logger.warning(msg, *args, **kwargs)：创建一个与方法名等级相同为warning的日志记录
• Logger.error(msg, *args, **kwargs)：创建一个与方法名等级相同为error的日志记录
• Logger.critical(msg, *args, **kwargs)：创建一个与方法名等级相同为critical的日志记录
• Logger.exception(msg, *args, exc_info=True, **kwargs)：创建一个类似Logger.error()的日志消息，但exception函数会输出堆栈追踪信息，通常在exception handler中调用
• Logger.log(level, msg, *args, **kwargs)：创建一个level参数的日志记录

2. 获取Logger对象

• logging.getLogger(name)：用来创建Logger对象
  name为可选参数，表示将要返回的日志器的名称标识；若不提供参数name，则默认返回root；使用同一name多次调用方法，则指向同一logger对象。

class Logger_object:
    """
    logger对象相关操作
    """
    def __init__(self):
        """
        返回logger对象
        """
        self.logger = logging.getLogger(__name__)

    def logger_info(self):
        """
        获取logger对象相关信息
        :return:
        """
        logger_name = self.logger.name          # 获取日志对象名称
        logger_level = self.logger.level        # 获取日志水平
        logger_filters = self.logger.filters    # 获取日志过滤器列表
        logger_handlers = self.logger.handlers  # 获取日志处理器列表
        logger_disabled = self.logger.disabled  # 获取日志对象是否为无效的
        print("logger_name=%s, logger_level=%s, logger_filters=%s, logger_handlers=%s, logger_disabled=%s"
              % (logger_name, logger_level, logger_filters, logger_handlers, logger_disabled))
        # 结果： logger_name=__main__, logger_level=0, logger_filters=[], logger_handlers=[], logger_disabled=False

    def logger_handler(self):
        """
        添加处理器addHandler，移除处理器removeHandler，判断是否有处理器hasHandlers
        :return:
        """
        self.logger.addHandler(hdlr="handler1")
        print(self.logger.handlers)     # 结果： ['handler1']
        self.logger.removeHandler(hdlr="handler1")
        print(self.logger.handlers)     # 结果： []
        has_handlers = self.logger.hasHandlers()
        print(has_handlers)             # 结果： False

    def logger_filter(self):
        """
        添加过滤器addFilter，移除过滤器removeFilter
        :return:
        """
        self.logger.addFilter(filter="filter1")
        print(self.logger.filters)                   # 结果为： ['filter1']
        self.logger.removeFilter(filter="filter1")
        print(self.logger.filters)                   # 结果为： []

    def logger_level(self):
        """
        设置日志等级setLevel，打印日志等级信息
        :return:
        """
        self.logger.setLevel(level=logging.DEBUG)
        self.logger.warning("This is a warning")
        self.logger.error("This is a error")
        self.logger.debug("This is a debug")
        self.logger.critical("This is a critical")
        self.logger.info("This is a info")
        self.logger.exception("This is a exception")
        self.logger.log(level=logging.CRITICAL, msg="This is a log")
        """结果
        This is a warning
        This is a error
        This is a critical
        This is a exception
        NoneType: None
        This is a log
        """
if __name__ == '__main__':
    logger_object = Logger_object()
    logger_object.logger_info()
    logger_object.logger_handler()
    logger_object.logger_filter()
    logger_object.logger_level()

三、Handler处理器

1. Handler对象方法

• Handler.setLevel(level)：设置处理器将会处理的日志消息的最低级别
• Handler.setFormatter(fmt)：为处理器设置格式器对象
• Handler.addFilter(filter)：为处理器添加过滤器对象
• Handler.removeFilter(filter)：为处理器删除过滤器对象

2. 获取Handler对象

• logging.StreamHandler([stream])：将日志消息输出到stream
• logging.FileHandler(filename[, ..])：将日志消息输出到文件，文件大小无限增长
• RotatingFileHandler(filename[, ..])：将日志消息输出到文件，并支持文件按大小切割
  模块导入方法：from logging.handlers import RotatingFileHandler
• HTTPHandler(host, url[, ..])：将日志消息通过GET或POST方式输出到HTTP服务器
  模块导入方法：from logging.handlers import HTTPHandler
• SMTPHandler(mailhost, fromaddr, toaddrs, subject[, ..])：将日志消息输出到邮件
  模块导入方法：from logging.handlers import SMTPHandler
• SocketHandler(host, port)：将日志消息输出到TCP/IP sockets
  模块导入方法：from logging.handlers import SocketHandler
  ......

三、Formatter对象

1. 日志格式化输出

可通过logging.basicConfig或logging.Formatter函数来配置格式化日志输出内容

• logging.Formatter(fmt=None, datefmt=None, style='%')

class Handler_object:
    """
    处理器对象相关操作
    """
    def __init__(self):
        """
        定义Logger对象和formatter对象
        """
        self.logger = logging.getLogger(__name__)
        self.logger.setLevel(level=logging.DEBUG)

        fmt_log = '%(asctime)s %(filename)s %(levelname)s %(message)s'
        date_fmt = '%Y%m%d %H:%M:%S'
        self.formatter = logging.Formatter(fmt=fmt_log, datefmt=date_fmt)

    def stream_handler(self):
        """
        设置处理器，将log信息输出到控制台
        :return:
        """
        import sys
        stream_handler = logging.StreamHandler(sys.stdout)
        stream_handler.setLevel(level=logging.INFO)
        stream_handler.setFormatter(fmt=self.formatter)
        self.logger.addHandler(hdlr=stream_handler)

    def file_handler(self):
        """
        设置处理器，将log信息输出到文件
        :return:
        """
        file_handler = logging.FileHandler(filename="D://out.log")
        file_handler.setLevel(level=logging.INFO)
        file_handler.setFormatter(fmt=self.formatter)
        self.logger.addHandler(hdlr=file_handler)
  
    def rotating_file_handler(self):
        """
        为避免日志过大，可通过日志回滚的方式设置日志文件大小
        每个日志文件最大为2K，最多备份3个
        :return:
        """
        from logging.handlers import RotatingFileHandler
        rotate_handler = RotatingFileHandler(filename="D://r_file.log", maxBytes=2*1024, backupCount=3)
        rotate_handler.setLevel(logging.INFO)
        rotate_handler.setFormatter(self.formatter)
        self.logger.addHandler(rotate_handler)
    def log(self):
        """
        输出log文件内容
        :return:
        """
        self.logger.info("This is a info")
        self.logger.debug("This is a debug")
        self.logger.critical("This is a critical")
        self.logger.warning("This is a warning")

if __name__ == '__main__':
    handler_object = Handler_object()
    handler_object.stream_handler()
    handler_object.file_handler()
    handler_object.rotating_file_handler()
    handler_object.log()
    """结果：out.log文件和控件台均会输出内容
    20190211 14:05:40 logging_operate.py INFO This is a info
    20190211 14:05:40 logging_operate.py CRITICAL This is a critical
    20190211 14:05:40 logging_operate.py WARNING This is a warning
    """

四、Filter对象

1. 介绍

Filter过滤器，它只允许某个Logger层级下的日志事件通过过滤。

2. 创建Filter对象

• logging.Filter(name='')：通过传递的name参数进行过滤
  如，参数name=‘A.B’，则会过滤A.B, A.B.D， A.B.E.F的日志；但A.BB，B.A的日志不会过滤。

五、封装一个简单的log保存代码

日志需同时输出到控制台和文件中

class LogUtil:
    """
    封闭简单的Log通用方法，同时将LOG输出到控制台和文件
    """
    def __init__(self, logger_name, log_level, log_file="log.txt"):
        """
        :param logger_name: Logger日志器的名称
        :param log_level: 日志水平
        :param log_file: 日志保存的文件（包括路径+文件）
        """
        self.logger_name = logger_name
        self.log_file = log_file
        self.log_level = log_level

    def operate(self):
        # 创建logger对象
        logger = logging.getLogger(self.logger_name)
        logger.setLevel(self.log_level)

        # 创建处理器，输出日志到log_file
        file_handler = logging.FileHandler(self.log_file)
        file_handler.setLevel(self.log_level)

        # 创建处理器，输出日志到控制台
        stream_handler = logging.StreamHandler()
        stream_handler.setLevel(self.log_level)

        # 定义处理器的输出格式
        fmt_log = '%(asctime)s %(name)s %(levelname)s %(message)s'
        date_fmt = '%Y%m%d %H:%M:%S'
        formatter = logging.Formatter(fmt=fmt_log, datefmt=date_fmt)
        file_handler.setFormatter(formatter)
        stream_handler.setFormatter(formatter)

        # 添加处理器到logger对象
        logger.addHandler(file_handler)
        logger.addHandler(stream_handler)
        return logger

# 实例调用log方法：计算5除以0，若出现异常时捕获异常
def div_calcul():
    logger = LogUtil(logger_name="divisionCal", log_level=logging.DEBUG, log_file="D://my.log").operate()
    try:
        result = 5 / 0
        print(result)
    except Exception as e:
        logger.critical("[calculation error：%s]" % e)
div_calcul()
"""结果
20190211 17:03:58 divisionCal CRITICAL [calculation error：division by zero]
"""