python 日志 logging 模块详解

爱被打了一巴掌 2022-11-20 01:55 288阅读 0赞

### 文章目录 ###

*  1 日志相关概念
 *   *  1.1 日志的作用
     *  1.2 日志的等级
     *  1.3 logging 模块两种使用方式
 *  2 使用 logging 提供的模块级别的函数
 *   *  2.1 logging 模块定义常用函数
     *  2.2 使用方式1：简单配置
     *  2.3 使用方式2：使用 logging.basicConfig() 函数
 *  3 使用 Logging 日志系统的四大组件
 *   *  3.1 Logger 类
     *  3.2 Handler 类
     *  3.3 Formater 类
     *  3.4 Filter类（了解即可）
     *  3.5 日志流处理简要流程

# 1 日志相关概念 #

## 1.1 日志的作用 ##

*  程序调试
 *  了解程序运行是否正常
 *  故障分析与问题定位
 *  用户行为分析

## 1.2 日志的等级 ##

<table> 
 <thead> 
  <tr> 
   <th>等级</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DEBUG</td> 
   <td align="left">最详细的日志信息，典型应用场景是问题诊断</td> 
  </tr> 
  <tr> 
   <td>INFO</td> 
   <td align="left">信息详细程度仅次于 DEBUG，通常只记录关键节点信息，用于确认一切都是按照我们预期的那样进行工作</td> 
  </tr> 
  <tr> 
   <td>WARNING</td> 
   <td align="left">当某些不期望的事情发生时记录的信息（如，磁盘可用空间较低），但是此时应用程序还是正常运行的</td> 
  </tr> 
  <tr> 
   <td>ERROR</td> 
   <td align="left">由于一个更严重的问题导致某些功能不能正常运行时记录的信</td> 
  </tr> 
  <tr> 
   <td>CRITICAL</td> 
   <td align="left">当发生严重错误，导致应用程序不能继续运行时记录的信息</td> 
  </tr> 
 </tbody> 
</table>

默认情况下，logging 模块将等级为 WARNING 及其以上的日志信息打印到控制台

## 1.3 logging 模块两种使用方式 ##

logging 模块有两种使用方式

*  第一种方式是使用 logging 提供的模块级别的函数
 *  第二种方式是使用 Logging 日志系统的四大组件

# 2 使用 logging 提供的模块级别的函数 #

## 2.1 logging 模块定义常用函数 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">logging.debug(msg,*args,**kwargs)</td> 
   <td align="left">创建一条严重级别为 DEBUG 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.info(msg,*args,*kwargs)</td> 
   <td align="left">创建一条严重级别为 INFO 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.warning(msg,*args,*kwargs)</td> 
   <td align="left">创建一条严重级别为 WARNING 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.error(msg,*args,*kwargs)</td> 
   <td align="left">创建一条严重级别为 ERROR 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.critical(msg,*args,**kwargs)</td> 
   <td align="left">创建一条严重级别为 CRITICAL 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.log(level,*args,*kwargs)</td> 
   <td align="left">创建一条严重级别为 level 的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">logging.basicConfig(**kwargs)</td> 
   <td align="left">对 root logger 进行一次性配置</td> 
  </tr> 
 </tbody> 
</table>

下面进行使用演示：

## 2.2 使用方式1：简单配置 ##

import logging
    
    logging.debug("debug message")
    logging.info("info message")
    logging.warning("warning message")
    logging.error("error message")
    logging.critical("critical message")
    logging.log(level=logging.ERROR, msg = "error in logging.log function")

输出结果：

WARNING:root:warning message
    ERROR:root:error message
    CRITICAL:root:critical message
    ERROR:root:error in logging.log function

默认情况下 logging 模块将日志打印到了标准输出中，且只显示大于等于 WARNING 级别的日志，这说明默认的日志级别设置为 WARNING（日志级别等级 CRITICAL > ERROR > WARNING > INFO > DEBUG）

## 2.3 使用方式2：使用 logging.basicConfig() 函数 ##

使用 logging.basicConfig() 函数可以调整日志级别、输出格式等

logging.basicConfig() 函数说明

<table> 
 <thead> 
  <tr> 
   <th align="left">参数名</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">filename</td> 
   <td align="left">指定日志输出目标文件的文件名，指定该设置项后日志信息就不会被输出到控制台了</td> 
  </tr> 
  <tr> 
   <td align="left">format</td> 
   <td align="left">指定日志格式字符串，即指定日志输出时所包含的字段信息以及它们的顺序。logging 模块定义的格式字段下面会列出。</td> 
  </tr> 
  <tr> 
   <td align="left">datefmt</td> 
   <td align="left">指定日期/时间格式。需要注意的是，该选项要在 format 中包含时间字段 %(asctime)s 时才有效</td> 
  </tr> 
  <tr> 
   <td align="left">level</td> 
   <td align="left">指定日志器的日志级别</td> 
  </tr> 
  <tr> 
   <td align="left">stream</td> 
   <td align="left">指定日志输出目标 stream，如 sys.stdout、sys.stderr 以及网络 stream。需要说明的是，stream 和 filename 不能同时提供，否则会引发 ValueError 异常</td> 
  </tr> 
  <tr> 
   <td align="left">style</td> 
   <td align="left">Python3.2 中新添加的配置项。指定 format 格式字符串的风格，可取值为 ‘%’、’{’ 和 ‘$’，默认为 ‘%’</td> 
  </tr> 
  <tr> 
   <td align="left">handlers</td> 
   <td align="left">Python 3.3 中新添加的配置项。该选项如果被指定，它应该是一个创建了多个 Handler 的可迭代对象，这些 handler 将会被添加到 rootlogger。需要说明的是：filename、stream 和 handlers 这三个配置项只能有一个存在，不能同时出现 2 个或 3 个，否则会引发 ValueError 异常。</td> 
  </tr> 
 </tbody> 
</table>

logging 模块的格式字符串

<table> 
 <thead> 
  <tr> 
   <th align="left">字段/属性名称</th> 
   <th align="left">使用格式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">asctime</td> 
   <td align="left">%(asctime)s</td> 
   <td align="left">日志事件发生的时间–人类可读时间，如：2003-07-08 16:49:45,896</td> 
  </tr> 
  <tr> 
   <td align="left">created</td> 
   <td align="left">%(created)f</td> 
   <td align="left">日志事件发生的时间–时间戳，就是当时调用 time.time() 函数返回的值</td> 
  </tr> 
  <tr> 
   <td align="left">relativeCreated</td> 
   <td align="left">%(relativeCreated)d</td> 
   <td align="left">日志事件发生的时间相对于 logging 模块加载时间的相对毫秒数（目前还不知道干嘛用的）</td> 
  </tr> 
  <tr> 
   <td align="left">msecs</td> 
   <td align="left">%(msecs)d</td> 
   <td align="left">日志事件发生事件的毫秒部分</td> 
  </tr> 
  <tr> 
   <td align="left">levelname</td> 
   <td align="left">%(levelname)s</td> 
   <td align="left">该日志记录的文字形式的日志级别（‘DEBUG’, ‘INFO’, ‘WARNING’, ‘ERROR’, ‘CRITICAL’）</td> 
  </tr> 
  <tr> 
   <td align="left">levelno</td> 
   <td align="left">%(levelno)s</td> 
   <td align="left">该日志记录的数字形式的日志级别（10, 20, 30, 40, 50）</td> 
  </tr> 
  <tr> 
   <td align="left">name</td> 
   <td align="left">%(name)s</td> 
   <td align="left">所使用的日志器名称，默认是 ‘root’，因为默认使用的是 rootLogger</td> 
  </tr> 
  <tr> 
   <td align="left">message</td> 
   <td align="left">%(message)s</td> 
   <td align="left">日志记录的文本内容，通过 msg % args 计算得到的</td> 
  </tr> 
  <tr> 
   <td align="left">pathname</td> 
   <td align="left">%(pathname)s</td> 
   <td align="left">调用日志记录函数的源码文件的全路径</td> 
  </tr> 
  <tr> 
   <td align="left">filename</td> 
   <td align="left">%(filename)s</td> 
   <td align="left">pathname 的文件名部分，包含文件后缀</td> 
  </tr> 
  <tr> 
   <td align="left">module</td> 
   <td align="left">%(module)s</td> 
   <td align="left">filename 的名称部分，不包含后缀</td> 
  </tr> 
  <tr> 
   <td align="left">lineno</td> 
   <td align="left">%(lineno)d</td> 
   <td align="left">调用日志记录函数的源代码所在的行号</td> 
  </tr> 
  <tr> 
   <td align="left">funcName</td> 
   <td align="left">%(funcName)s</td> 
   <td align="left">调用日志记录函数的函数名</td> 
  </tr> 
  <tr> 
   <td align="left">process</td> 
   <td align="left">%(process)d</td> 
   <td align="left">进程 ID</td> 
  </tr> 
  <tr> 
   <td align="left">processName</td> 
   <td align="left">%(processName)s</td> 
   <td align="left">进程名称，Python 3.1 新增</td> 
  </tr> 
  <tr> 
   <td align="left">thread</td> 
   <td align="left">%(thread)d</td> 
   <td align="left">线程 ID</td> 
  </tr> 
  <tr> 
   <td align="left">threadName</td> 
   <td align="left">%(thread)s</td> 
   <td align="left">线程名称</td> 
  </tr> 
 </tbody> 
</table>

# coding=utf-8
    import logging
    
    MY_FORMAT = "%(asctime)s %(name)s %(levelname)s %(pathname)s %(lineno)d %(message)s"  # 配置输出日志格式
    DATE_FORMAT = '%Y-%m-%d  %H:%M:%S %a '  #配置输出时间的格式
    
    logging.basicConfig(
        filename="my.log",  # 指定日志写入到文件
        level=logging.INFO,
        datefmt=DATE_FORMAT,
        format=MY_FORMAT,
    )
    
    logging.debug("debug")
    logging.info("info")
    logging.warning("warning")
    logging.error("error")
    logging.critical("critical")

打开文件 my.log，内容如下：

2020-11-22  19:18:58 Sun  root INFO E:/prapy/python_project/testcase/test1.py 15 info
    2020-11-22  19:18:58 Sun  root WARNING E:/prapy/python_project/testcase/test1.py 16 warning
    2020-11-22  19:18:58 Sun  root ERROR E:/prapy/python_project/testcase/test1.py 17 error
    2020-11-22  19:18:58 Sun  root CRITICAL E:/prapy/python_project/testcase/test1.py 18 critical

说明：

*  logging.basicConfig() 函数是一个一次性的简单配置工具使，也就是说只有在第一次调用该函数时会起作用，后续再次调用该函数时完全不会产生任何操作的，多次调用的设置并不是累加操作。
 *  日志器（Logger）是有层级关系的，上面调用的 logging 模块级别的函数所使用的日志器是 RootLogger 类的实例，其名称为 ‘root’，它是处于日志器层级关系最顶层的日志器，且该实例是以单例模式存在的。
 *  如果要记录的日志中包含变量数据，可使用一个格式字符串作为这个事件的描述消息（logging.debug、logging.info 等函数的第一个参数），然后将变量数据作为第二个参数 \*args 的值进行传递，

>>> import logging
    >>> logging.warning('%s is %d years old.', 'Tom', 10)
    WARNING:root:Tom is 10 years old.

# 3 使用 Logging 日志系统的四大组件 #

上面我们了解到了 logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到 root logger（根 Logger）中）这几个 logging 模块级别的函数。

下面介绍第二种打印日志的方法，日志流处理，使用函数 logging.getLogger(\[name\])（返回一个 logger 对象，如果没有指定名字将返回 root logger）。

在介绍 logging 模块的日志流处理流程之前，我们先来介绍下 logging 模块的四大组件：

<table> 
 <thead> 
  <tr> 
   <th align="left">组件名称</th> 
   <th align="left">对应类名</th> 
   <th align="left">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">日志器</td> 
   <td align="left">Logger</td> 
   <td align="left">提供了应用程序可一直使用的接口</td> 
  </tr> 
  <tr> 
   <td align="left">处理器</td> 
   <td align="left">Handler</td> 
   <td align="left">将 logger 创建的日志记录发送到合适的目的输出</td> 
  </tr> 
  <tr> 
   <td align="left">过滤器</td> 
   <td align="left">Filter</td> 
   <td align="left">提供了更细粒度的控制工具来决定输出哪条日志记录，丢弃哪条日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">格式器</td> 
   <td align="left">Formatter</td> 
   <td align="left">决定日志记录的最终输出格式</td> 
  </tr> 
 </tbody> 
</table>

**这些组件之间的关系描述：**

*  日志器（logger）需要通过处理器（handler）将日志信息输出到目标位置，如：文件、sys.stdout、网络等；
 *  不同的处理器（handler）可以将日志输出到不同的位置；
 *  日志器（logger）可以设置多个处理器（handler）将同一条日志记录输出到不同的位置；
 *  每个处理器（handler）都可以设置自己的过滤器（filter）实现日志过滤，从而只保留感兴趣的日志；
 *  每个处理器（handler）都可以设置自己的格式器（formatter）实现同一条日志以不同的格式输出到不同的地方。

简单点说就是：日志器（logger）是入口，真正干活儿的是处理器（handler），处理器（handler）还可以通过过滤器（filter）和格式器（formatter）对要输出的日志内容做过滤和格式化等处理操作。

**logging 日志模块相关类及其常用方法介绍**

与 logging 四大组件相关的类：Logger, Handler, Filter, Formatter。

## 3.1 Logger 类 ##

Logger 对象有 3 个任务要做：

1.  向应用程序代码暴露几个方法，使应用程序可以在运行时记录日志消息；
2.  基于日志严重等级（默认的过滤设施）或 filter 对象来决定要对哪些日志进行后续处理；
3.  将日志消息传送给所有感兴趣的日志 handlers。

Logger 对象最常用的方法分为两类：配置方法和消息发送方法

**Logger 类相关方法**

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Logger.setLevel()</td> 
   <td align="left">设置日志器将会处理的日志消息的最低严重级别</td> 
  </tr> 
  <tr> 
   <td align="left">Logger.addHandler() 和 Logger.removeHandler()</td> 
   <td align="left">为该logger对象添加 和 移除一个handler对象</td> 
  </tr> 
  <tr> 
   <td align="left">Logger.addFilter() 和 Logger.removeFilter()</td> 
   <td align="left">为该logger对象添加 和 移除一个filter对象</td> 
  </tr> 
 </tbody> 
</table>

logger对象配置完成后，可以使用下面的方法来创建日志记录：

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Logger.debug(), Logger.info(), Logger.warning(), <br>Logger.error(), Logger.critical()</td> 
   <td align="left">创建一个与它们的方法名对应等级的日志记录</td> 
  </tr> 
  <tr> 
   <td align="left">Logger.exception()</td> 
   <td align="left">创建一个类似于 Logger.error() 的日志消息</td> 
  </tr> 
  <tr> 
   <td align="left">Logger.log()</td> 
   <td align="left">需要获取一个明确的日志 level 参数来创建一个日志记录</td> 
  </tr> 
 </tbody> 
</table>

一个 Logger 对象呢？一种方式是通过 Logger 类的实例化方法创建一个 Logger 类的实例，但是我们通常都是用第二种方式–logging.getLogger() 方法。

logging.getLogger() 方法有一个可选参数 name，该参数表示将要返回的日志器的名称标识，如果不提供该参数，则其值为 ‘root’。若以相同的 name 参数值多次调用 getLogger() 方法，将会返回指向同一个 logger 对象的引用。

多次使用注意不能创建多个logger,否则会出现重复输出日志现象。

**关于logger的层级结构与有效等级的说明：**

*  logger的名称是一个以 ‘.’ 分割的层级结构，每个 ‘.’ 后面的 logger 都是 ‘.’ 前面的 logger 的 children，例如，有一个名称为 foo 的 logger，其它名称分别为 foo.bar, foo.bar.baz 和 foo.bam 都是 foo 的后代。
 *  logger 有一个"有效等级（effective level）"的概念。如果一个 logger 上没有被明确设置一个 level，那么该 logger 就是使用它 parent 的 level；如果它的 parent 也没有明确设置 level 则继续向上查找 parent 的 parent 的有效 level，依次类推，直到找到个一个明确设置了 level 的祖先为止。需要说明的是，root logger 总是会有一个明确的 level 设置（默认为 WARNING）。当决定是否去处理一个已发生的事件时，logger 的有效等级将会被用来决定是否将该事件传递给该 logger 的 handlers 进行处理。
 *  child loggers 在完成对日志消息的处理后，默认会将日志消息传递给与它们的祖先 loggers 相关的 handlers。因此，我们不必为一个应用程序中所使用的所有 loggers 定义和配置 handlers，只需要为一个顶层的 logger 配置 handlers，然后按照需要创建 child loggers 就可足够了。我们也可以通过将一个 logger 的 propagate 属性设置为 False 来关闭这种传递机制。

## 3.2 Handler 类 ##

Handler 对象的作用是（基于日志消息的 level）将消息分发到 handler 指定的位置（文件、网络、邮件等）。Logger 对象可以通过 addHandler() 方法为自己添加 0 个或者更多个 handler 对象。比如，一个应用程序可能想要实现以下几个日志需求：

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Handler.setLevel(lel)</td> 
   <td align="left">指定被处理的信息级别，低于 lel 级别的信息将被忽略</td> 
  </tr> 
  <tr> 
   <td align="left">Handler.setFormatter()</td> 
   <td align="left">给这个 handler 选择一个格式</td> 
  </tr> 
  <tr> 
   <td align="left">Handler.addFilter(filt)、Handler.removeFilter(filt)</td> 
   <td align="left">新增或删除一个 filter 对象</td> 
  </tr> 
 </tbody> 
</table>

需要说明的是，应用程序代码不应该直接实例化和使用 Handler 实例。因为 Handler 是一个基类，它只定义了所有 handlers 都应该有的接口，同时提供了一些子类可以直接使用或覆盖的默认行为。下面是一些常用的 Handler：

<table> 
 <thead> 
  <tr> 
   <th align="left">Handler</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">logging.StreamHandler</td> 
   <td align="left">将日志消息发送到输出到 Stream，如 std.out, std.err 或任何 file-like 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">logging.FileHandler</td> 
   <td align="left">将日志消息发送到磁盘文件，默认情况下文件大小会无限增长</td> 
  </tr> 
  <tr> 
   <td align="left">logging.handlers.RotatingFileHandler</td> 
   <td align="left">将日志消息发送到磁盘文件，并支持日志文件按大小切割</td> 
  </tr> 
  <tr> 
   <td align="left">logging.hanlders.TimedRotatingFileHandler</td> 
   <td align="left">将日志消息发送到磁盘文件，并支持日志文件按时间切割</td> 
  </tr> 
  <tr> 
   <td align="left">logging.handlers.HTTPHandler</td> 
   <td align="left">将日志消息以 GET 或 POST 的方式发送给一个 HTTP 服务器</td> 
  </tr> 
  <tr> 
   <td align="left">logging.handlers.SMTPHandler</td> 
   <td align="left">将日志消息发送给一个指定的 email 地址</td> 
  </tr> 
  <tr> 
   <td align="left">logging.NullHandler</td> 
   <td align="left">该 Handler 实例会忽略 error messages，通常被想使用 logging 的 library 开发者使用来避免 ‘No handlers could be found for logger XXX’ 信息的出现。</td> 
  </tr> 
 </tbody> 
</table>

## 3.3 Formater 类 ##

Formater 对象用于配置日志信息的最终顺序、结构和内容。与 logging.Handler基类不同的是，应用代码可以直接实例化 Formatter 类。另外，如果你的应用程序需要一些特殊的处理行为，也可以实现一个 Formatter 的子类来完成。

Formatter 类的构造方法定义如下：

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

可见，该构造方法接收 3 个可选参数：

*  fmt：指定消息格式化字符串，如果不指定该参数则默认使用 message 的原始值
 *  datefmt：指定日期格式字符串，如果不指定该参数则默认使用 “%Y-%m-%d %H:%M:%S”
 *  style：Python 3.2 新增的参数，可取值为 ‘%’，’\{’ 和 ‘$’，如果不指定该参数则默认使用 ‘%’

一般直接用 logging.Formatter(fmt, datefmt)

## 3.4 Filter类（了解即可） ##

Filter 可以被 Handler 和 Logger 用来做比 level 更细粒度的、更复杂的过滤功能。Filter 是一个过滤器基类，它只允许某个 logger 层级下的日志事件通过过滤。该类定义如下：

class logging.Filter(name='')
        filter(record)

比如，一个 filter 实例化时传递的 name 参数值为 ‘A.B’，那么该 filter 实例将只允许名称为类似如下规则的 loggers 产生的日志记录通过滤：‘A.B’，‘A.B,C’，‘A.B.C.D’，‘A.B.D’，而名称为 ‘A.BB’，‘B.A.B’ 的 loggers 产生的日志则会被过滤掉。如果 name 的值为空字符串，则允许所有的日志事件通过过滤。

filter 方法用于具体控制传递的 record 记录是否能通过过滤，如果该方法返回值为0表示不能通过过滤，返回值为非 0 表示可以通过过滤。

## 3.5 日志流处理简要流程 ##

1、创建一个 logger  
2、设置下 logger 的日志的等级  
3、创建合适的 Handler(FileHandler 要有路径)  
4、设置下每个 Handler 的日志等级  
5、创建下日志的格式  
6、向 Handler 中添加上面创建的格式  
7、将上面创建的 Handler 添加到 logger 中  
8、打印输出 logger.debug\\logger.info\\logger.warning\\logger.error\\logger.critical

# coding=utf-8
    import logging
    
    # 创建logger，如果参数为空则返回 root logger
    logger = logging.getLogger("mylogger")
    logger.setLevel(logging.DEBUG)  # 设置logger日志等级
    
    # 创建handler
    fh = logging.FileHandler("test.log", encoding="utf-8")
    ch = logging.StreamHandler()
    
    # 设置输出日志格式, 注意 logging.Formatter的大小写
    formatter = logging.Formatter(
        fmt="%(asctime)s %(name)s %(filename)s %(message)s",
        datefmt="%Y/%m/%d %X"
    )
    
    # 为handler指定输出格式，注意大小写
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)
    
    # 为logger添加的日志处理器
    logger.addHandler(fh)
    logger.addHandler(ch)
    
    # 输出不同级别的log
    logger.warning("warning message")
    logger.info("info message")
    logger.error("error message")

运行结果

2020/11/22 21:00:24 mylogger test3.py warning message
    2020/11/22 21:00:24 mylogger test3.py info message
    2020/11/22 21:00:24 mylogger test3.py error message

**python logging 重复写日志问题**

用 Python 的 logging 模块记录日志时，可能会遇到重复记录日志的问题，第一条记录写一次，第二条记录写两次，第三条记录写三次

**原因：没有移除 handler 解决：在日志记录完之后 removeHandler**

# coding=utf-8
    import logging
    
    def log(msg):
        #创建logger，如果参数为空则返回root logger
        logger = logging.getLogger("mylogger")
        logger.setLevel(logging.DEBUG)  #设置logger日志等级
    
        #创建handler
        fh = logging.FileHandler("test.log",encoding="utf-8")
        ch = logging.StreamHandler()
    
        #设置输出日志格式
        formatter = logging.Formatter(
            fmt="%(asctime)s %(name)s %(filename)s %(message)s",
            datefmt="%Y/%m/%d %X"
            )
    
        #为handler指定输出格式
        fh.setFormatter(formatter)
        ch.setFormatter(formatter)
    
        #为logger添加的日志处理器
        logger.addHandler(fh)
        logger.addHandler(ch)
    
        # 输出不同级别的log
        logger.info(msg)
    
    # 输出不同级别的log
    log("message1")
    log("message2")
    log("message3")

运行结果

2020/11/22 21:08:04 mylogger test3.py message1
    2020/11/22 21:08:04 mylogger test3.py message2
    2020/11/22 21:08:04 mylogger test3.py message2
    2020/11/22 21:08:04 mylogger test3.py message3
    2020/11/22 21:08:04 mylogger test3.py message3
    2020/11/22 21:08:04 mylogger test3.py message3

**分析**：可以看到输出结果有重复打印

原因：第二次调用 log 的时候，根据 getLogger(name) 里的 name 获取同一个logger，而这个 logger 里已经有了第一次你添加的 handler，第二次调用又添加了一个 handler，所以，这个 logger 里有了两个同样的 handler，以此类推，调用几次就会有几个 handler。

**解决方案 1：添加 removeHandler 语句**

# coding=utf-8
    import logging
    
    
    def log(msg):
        # 创建logger，如果参数为空则返回root logger
        logger = logging.getLogger("mylogger")
        logger.setLevel(logging.DEBUG)  # 设置logger日志等级
    
        # 创建handler
        fh = logging.FileHandler("test.log", encoding="utf-8")
        ch = logging.StreamHandler()
    
        # 设置输出日志格式
        formatter = logging.Formatter(
            fmt="%(asctime)s %(name)s %(filename)s %(message)s",
            datefmt="%Y/%m/%d %X"
        )
    
        # 为handler指定输出格式
        fh.setFormatter(formatter)
        ch.setFormatter(formatter)
    
        # 为logger添加的日志处理器
        logger.addHandler(fh)
        logger.addHandler(ch)
    
        # 输出不同级别的log
        logger.info(msg)
    
        # 解决方案1，添加removeHandler语句，每次用完之后移除Handler
        logger.removeHandler(fh)
        logger.removeHandler(ch)
    
    
    # 输出不同级别的log
    log("message1")
    log("message2")
    log("message3")

**解决方案 2：在 log 方法里做判断，如果这个 logger 已有 handler，则不再添加 handler。**

# coding=utf-8
    import logging
    
    
    def log(msg):
        # 创建logger，如果参数为空则返回root logger
        logger = logging.getLogger("mylogger")
        logger.setLevel(logging.DEBUG)  # 设置logger日志等级
    
        if not logger.handlers:
            # 创建handler
            fh = logging.FileHandler("test.log", encoding="utf-8")
            ch = logging.StreamHandler()
    
            # 设置输出日志格式
            formatter = logging.Formatter(
                fmt="%(asctime)s %(name)s %(filename)s %(message)s",
                datefmt="%Y/%m/%d %X"
            )
    
            # 为handler指定输出格式
            fh.setFormatter(formatter)
            ch.setFormatter(formatter)
    
            # 为logger添加的日志处理器
            logger.addHandler(fh)
            logger.addHandler(ch)
    
        # 输出不同级别的log
        logger.info(msg)
    
    
    # 输出不同级别的log
    log("message1")
    log("message2")
    log("message3")

**logger 调用方法的例子**

# coding=utf-8
    import logging.handlers
    import datetime
    
    
    def get_logger():
        logger = logging.getLogger('mylogger')  # mylogger为日志器的名称标识，如果不提供该参数，默认为'root'
        logger.setLevel(logging.DEBUG)  # 设置logger处理等级
    
        # 这里进行判断，如果logger.handlers列表为空，则添加，否则，直接去写日志
        if not logger.handlers:
            # rf_handler将所有的日志信息写到 all.log 中
            # when:字符串，定义了日志切分的间隔时间单位
            # interval:间隔时间单位的个数，指等待多少个when的时间后Logger会自动重建新闻继续进行日志记录
            # backupCount 是保留日志的文件个数，日志文件最多backupCount个，多余的删除，默认为0，表示不会自动删除
            rf_handler = logging.handlers.TimedRotatingFileHandler('all.log', when='midnight', interval=1, backupCount=7,
                                                                   atTime=datetime.time(0, 0, 0, 0))
    
            # 设置输出日志格式
            rf_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
            # 为handler指定输出格式
            rf_handler.setFormatter(rf_formatter)
    
            # f_handler 将等级大于等于 error的信息写到error.log文件中
            f_handler = logging.FileHandler('error.log')
            f_handler.setLevel(logging.ERROR)
    
            # 设置输出日志格式
            f_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(filename)s[:%(lineno)d] - %(message)s")
            # 为handler指定输出格式
            f_handler.setFormatter(f_formatter)
    
            # 为logger添加的日志处理器
            logger.addHandler(rf_handler)
            logger.addHandler(f_handler)
    
        return logger
    
    
    logger = get_logger()
    logger.debug('debug message')
    logger.info('info message')
    logger.warning('warning message')
    logger.error('error message')
    logger.critical('critical message')
    logger.log(level=logging.ERROR, msg="logger.log message")

参考：https://www.cnblogs.com/Nicholas0707/p/9021672.html\#\_label1\_1