Python入门之——logging日志模块 Basic Logging Tutorial

浅浅的花香味﹌ 2022-12-03 05:22 166阅读 0赞

logging — Logging facility for Python 源代码位置：Lib/logging/\_\_init\_\_.py  
该模块定义函数和类，这些函数和类为应用程序和库实现了灵活的事件日志记录系统。由标准库模块提供的日志记录API的主要好处是所有Python模块都可以参与日志记录，因此您的应用程序日志可以包括您自己的消息以及与第三方模块的消息集成的消息。  
下面列出了模块定义的基本类及其功能。

*  Loggers expose the interface that application code directly uses.
 *  Handlers send the log records (created by loggers) to the appropriate destination.
 *  Filters provide a finer grained facility for determining which log records to output.
 *  Formatters specify the layout of log records in the final output.

日志记录是一种跟踪某些软件运行时发生的事件的方法。 该软件的开发人员在其代码中添加了日志记录调用，以指示发生了某些事件。 事件由描述性消息描述，该消息可以可选地包含变量数据（即，每次事件发生时都可能不同的数据）。 事件也具有开发者认为该事件的重要性。 重要性也可以称为级别或严重性。

日志记录提供了一组便利功能，可简化日志记录的用法：debug(), info(), warning(), error() and critical()，和日志级别对应。

<table> 
 <thead> 
  <tr> 
   <th>你想执行的任务</th> 
   <th>工具</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Display console output for ordinary usage of a command line script or program</td> 
   <td>print()</td> 
  </tr> 
  <tr> 
   <td>Report events that occur during normal operation of a program (e.g. for status monitoring or fault investigation)</td> 
   <td>logging.info() (or logging.debug() for very detailed output for diagnostic purposes)</td> 
  </tr> 
  <tr> 
   <td>Issue a warning regarding a particular runtime event</td> 
   <td>warnings.warn() in library code if the issue is avoidable and the client application should be modified to eliminate the warning. logging.warning() if there is nothing the client application can do about the situation, but the event should still be noted</td> 
  </tr> 
  <tr> 
   <td>Report an error regarding a particular runtime event</td> 
   <td>Raise an exception</td> 
  </tr> 
  <tr> 
   <td>Report suppression of an error without raising an exception (e.g. error handler in a long-running server process)</td> 
   <td>logging.error(), logging.exception() or logging.critical() as appropriate for the specific error and application domain</td> 
  </tr> 
 </tbody> 
</table>

# 模块级别的函数 Module-Level Functions #

`logging.getLogger(name=None)`  
返回具有指定名称name的记录器logger，如果名称name为None，则返回一个记录器logger，该logger是层次结构的根记录器(root logger)。 name通常是点分隔的层次结构，例如“ a”，“ a.b”或“ a.b.c.d”。 这些名称的选择完全取决于正在使用日志记录的开发人员。使用传入给定名称name对getLogger函数的所有调用均返回相同的记录器实例。 这意味着记录器实例永远不需要在应用程序的不同部分之间传递。

`logging.getLoggerClass()`  
返回标准Logger类或者通过setLoggerClass设置的类。该函数主要用于创建类定义以实现自定义的Logger类型

class MyLogger(logging.getLoggerClass()):
        # ... override behaviour here

`logging.setLoggerClass(klass)`  
告诉日志记录系统在实例化记录器logger时使用类klass。 该类应定义\_\_init\\ \_\_()，以便仅需要一个名称参数，而\_\_init\\ \_\_()则应调用Logger.\_\_ init\\ \_\_()。 通常在需要使用自定义记录器行为的应用程序实例化任何记录器之前，会调用此函数。 在此调用之后，就像在其他任何时间一样，请勿直接使用子类实例化记录器：继续使用logging.getLogger()来获取记录器。

`logging.getLogRecordFactory()`  
返回用于创建LogRecord的可调用对象。3.2版中的新增功能：此功能与setLogRecordFactory()一起提供，以使开发人员可以更好地控制表示记录事件的LogRecord的构造方式。有关如何调用工厂的更多信息，请参见setLogRecordFactory。  
`logging.setLogRecordFactory(factory)`  
设置可调用对象以创建LogRecord  
3.2版中的新增功能：此函数与getLogRecordFactory一起提供，以使开发人员可以更好地控制表示日志记录事件的LogRecord的构造方式。  
工厂具有以下签名：factory(name, level, fn, lno, msg, args, exc\_info, func=None, sinfo=None, \*\*kwargs)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]

`logging.debug(msg, *args, **kwargs)`  
在根记录器root logger上记录级别为DEBUG的消息。msg是消息格式字符串，而args是使用字符串格式运算符合并到msg中的参数。（请注意，这意味着您可以在格式字符串中使用关键字以及单个字典参数。）  
在kwargs中检查了三个关键字参数：exc\_info，如果不将其设置为false，则会将异常信息添加到日志消息中。如果提供了一个异常元组（以sys.exc\_info()返回的格式）或一个异常实例，则将使用它。否则，将调用sys.exc\_info()以获取异常信息。第二个可选关键字参数是stack\_info，默认为False。如果为true，则将堆栈信息添加到日志消息中，包括实际的日志调用。请注意，这与通过指定exc\_info显示的堆栈信息不同：前者是从堆栈底部到当前线程中的日志记录调用的堆栈帧，而后者是有关unwound的堆栈帧的信息，在搜索异常处理程序时跟踪异常。（The former is stack frames from the bottom of the stack up to the logging call in the current thread, whereas the latter is information about stack frames which have been unwound, following an exception, while searching for exception handlers.）  
您可以独立于exc\_info来指定stack\_info，例如仅显示您如何到达代码中的特定点，即使没有引发异常也是如此。堆栈框架在标题行之后打印：`Stack (most recent call last):`。第三个可选关键字参数是extra，可用于传递字典，该字典用于使用用户定义的属性填充为日志事件创建的LogRecord的\_\_dict\_\_。 然后可以根据需要使用这些自定义属性。 例如，可以将它们合并到已记录的消息中。 例如：

FORMAT = '%(asctime)-15s %(clientip)s %(user)-8s %(message)s'
    logging.basicConfig(format=FORMAT)
    d = { 'clientip': '192.168.0.1', 'user': 'fbloggs'}
    logging.warning('Protocol problem: %s', 'connection reset', extra=d)

打印信息如下：2006-02-08 22:20:02,165 192.168.0.1 fbloggs Protocol problem: connection reset  
额外传入的字典中的键不应与日志系统使用的键冲突。 （有关日志记录系统使用哪些键的更多信息，请参见格式化程序文档。）  
如果选择在已记录的消息中使用这些属性，则需要格外小心。 例如，在上面的示例中，格式化程序已设置为格式字符串，该字符串在LogRecord的属性字典中应为“ clientip”和“ user”。 如果缺少这些内容，则将不会记录该消息，因为会发生字符串格式化异常。 因此，在这种情况下，您始终需要使用这些键传递额外的字典。  
尽管这可能很烦人，但是此功能旨在用于特殊情况，例如在多个上下文中执行相同代码的多线程服务器，并且出现的有趣条件取决于此上下文（例如，远程客户端IP地址和已验证用户名，在上面的示例中）。 在这种情况下，可能会将特殊的格式化程序与特定的处理程序一起使用。在版本3.2中更改：添加了stack\_info参数。  
`logging.info(msg, *args, **kwargs)`  
在根记录器上记录级别为INFO的消息。Logs a message with level INFO on the root logger.  
`logging.warning(msg, *args, **kwargs)`  
在根记录器上记录级别为warning的消息。Logs a message with level WARNING on the root logger.  
`logging.error(msg, *args, **kwargs)`  
在根记录器上记录级别为error的消息。Logs a message with level ERROR on the root logger.  
`logging.critical(msg, *args, **kwargs)`  
在根记录器上记录级别为critical的消息。Logs a message with level CRITICAL on the root logger.  
`logging.exception(msg, *args, **kwargs)`  
在根记录器上记录级别为exception的消息。Logs a message with level ERROR on the root logger. 异常信息将添加到日志消息中。 仅应从异常处理程序中调用此函数。  
`logging.log(level, msg, *args, **kwargs)`  
在根记录器上记录级别为level的消息。Logs a message with level level on the root logger.  
**上面的模块级函数委托给root记录器**，调用basicConfig()以确保至少有一个处理程序可用。 因此，除非在启动线程之前已在根记录器中添加至少一个处理程序handler，否则在2.7.1和3.2之前的Python版本中，不应在线程中使用它们。 在Python的早期版本中，由于basicConfig()中的线程安全性不足，这可能（在极少数情况下）导致将处理程序多次添加到根记录器中，这反过来又可能导致同一事件的多个消息。

`logging.disable(level=CRITICAL)`  
为所有记录器logger提供一个优先级别，该级别优先于记录器自己的级别。当需要临时限制整个应用程序中的日志记录输出时，此功能很有用。它的作用是禁用所有严重性及以下级别的日志记录调用，因此，如果您使用INFO值调用它，则将丢弃所有INFO和DEBUG事件，而严重性为WARNING及以上的事件将根据记录器的处理方式进行处理。如果调用logging.disable(logging.NOTSET)，它将有效地删除此覆盖级别，因此，日志记录输出再次取决于各个记录器的有效级别。请注意，如果您定义了高于CRITICAL的任何自定义日志记录级别（不建议这样做），则您将不能依赖level参数的默认值，而必须显式提供合适的值。在版本3.7中更改：级别参数默认为级别CRITICAL。有关此更改的更多信息，请参见问题＃28524。

`logging.addLevelName(level, levelName)`  
将级别level与内部字典中的文本levelName关联，该字典用于将数字级别映射到文本表示形式，例如，当Formatter格式化消息时。 此功能还**可用于定义您自己的级别**。 唯一的限制是所使用的所有级别都必须使用此功能进行注册，级别应为正整数，并且应按照严重性从高到低的顺序递增。  
`logging.getLevelName(level)`  
返回日志记录级别level的文本表示形式。 如果级别是CRITICAL，ERROR，WARNING，INFO或DEBUG的预定义级别之一，那么您将获得相应的字符串。 如果使用addLevelNam()）将级别与名称相关联，则将返回与级别相关联的名称。 如果传入了与定义的级别之一相对应的数值，则返回相应的字符串表示形式。 否则，返回字符串’Level％s’％level。  
级别是内部整数（因为它们需要在日志记录逻辑中进行比较）。 此函数用于通过％（levelname）s格式说明符在整数级别和格式化日志输出中显示的级别名称之间进行转换（请参阅LogRecord属性）。  
在3.4版中进行了更改：在3.4版之前的Python版本中，此函数也可以传递文本级别，并返回该级别的相应数值。 这种未记录的行为被视为错误，已在Python 3.4中删除，但由于保留了向后兼容性，在3.4.2中将其恢复。

`logging.makeLogRecord(attrdict)`  
创建并返回一个新的LogRecord实例，该实例的属性由attrdict定义。 此功能对于获取pickled的LogRecord属性字典（通过套接字发送）并将其重构为接收端的LogRecord实例很有用。

`logging.basicConfig(**kwargs)`  
通过创建带有默认Formatter的StreamHandler并将其添加到根记录器root logger，对记录系统进行基本配置。 如果没有为根记录器定义处理程序handler，则debug（），info（），warning（），error（）和critical（）函数将自动调用basicConfig（）。如果根记录器已经配置了处理程序，则此功能将不执行任何操作，除非将关键字参数force设置为True。  
在启动其他线程之前，应从主线程调用此函数。 在2.7.1和3.2之前的Python版本中，如果从多个线程调用此函数，则有可能（在极少数情况下）多次将处理程序添加到根记录器中，从而导致意外结果，例如消息 在日志中被复制。

<table> 
 <thead> 
  <tr> 
   <th>Format</th> 
   <th>Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>filename</td> 
   <td>使用指定文件名创建FileHandler</td> 
  </tr> 
  <tr> 
   <td>filemode</td> 
   <td>如果filename指定，使用filemode打开文件，默认是a，追加</td> 
  </tr> 
  <tr> 
   <td>format</td> 
   <td>为handler使用指定format string</td> 
  </tr> 
  <tr> 
   <td>datefmt</td> 
   <td>使用指定date/time格式</td> 
  </tr> 
  <tr> 
   <td>style</td> 
   <td>如果指定format，使用为format string使用该style。One of ‘%’, ‘{’ or ‘$’ for printf-style, str.format() or string.Template respectively. Defaults to ‘%’</td> 
  </tr> 
  <tr> 
   <td>level</td> 
   <td>将root logger级别设置为指定level</td> 
  </tr> 
  <tr> 
   <td>stream</td> 
   <td>使用指定stream初始化StreamHandler。和filename不能同时指定</td> 
  </tr> 
  <tr> 
   <td>handlers</td> 
   <td>如果指定，应该是已经创建的可迭代的处理程序handler，并添加到根记录器。 任何尚未设置格式器的处理程序都将被分配此函数中创建的默认格式器。 请注意，此参数与filename或stream不兼容-如果同时存在，则会引发ValueError。</td> 
  </tr> 
  <tr> 
   <td>force</td> 
   <td>如果将此关键字参数指定为true，则在执行其他参数指定的配置之前，将删除并关闭附加到根记录程序的所有现有处理程序。</td> 
  </tr> 
 </tbody> 
</table>

`logging.shutdown()`  
通过刷新和关闭所有处理程序来通知日志记录系统执行有序的关闭。 这应该在应用程序出口处调用，并且在此调用之后不应进一步使用日志记录系统。导入日志记录模块时，它将此功能注册为退出处理程序（请参阅atexit），因此通常无需手动执行此操作。

## 日志级别 ##

跟踪的事件可以以不同的方式处理。 处理跟踪事件的最简单方法是将它们打印到控制台。 另一种常见的方法是将它们写入磁盘文件。

import logging  # 引入logging模块
    # 将信息打印到控制台上
    logging.debug(u"苍井空")
    logging.info(u"麻生希")
    logging.warning(u"小泽玛利亚")
    logging.error(u"桃谷绘里香")
    logging.critical(u"泷泽萝拉")

输出显示，可以看到只有后面三个能打印出来，原因是默认生成的root logger的level是logging.WARNING,低于该级别的就不输出了![在这里插入图片描述][2020090121594168.png_pic_center]  
级别排序:CRITICAL > ERROR > WARNING > INFO > DEBUG

*  debug : 打印全部的日志,详细的信息,通常只出现在诊断问题上
 *  info : 打印info,warning,error,critical级别的日志,确认一切按预期运行
 *  warning : 打印warning,error,critical级别的日志,一个迹象表明,一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”),这个软件还能按预期工作
 *  error : 打印error,critical级别的日志,更严重的问题,软件没能执行一些功能
 *  critical : 打印critical级别,一个严重的错误,这表明程序本身可能无法继续运行

这时候，如果需要显示低于WARNING级别的内容，可以引入NOTSET级别来显示：

import logging  # 引入logging模块
    logging.basicConfig(level=logging.NOTSET)  # 设置日志级别
    logging.debug(u"如果设置了日志级别为NOTSET,那么这里可以采取debug、info的级别的内容也可以显示在控制台上了")

![在这里插入图片描述][20200901220608479.png_pic_center]

## 部分名词解释 ##

Logging.Formatter：这个类配置了日志的格式，在里面自定义设置日期和时间，输出日志的时候将会按照设置的格式显示内容。  
Logging.Logger：Logger是Logging模块的主体，进行以下三项工作：

1.  为程序提供记录日志的接口
2.  判断日志所处级别，并判断是否要过滤
3.  根据其日志级别将该条日志分发给不同handler

常用函数有：  
Logger.setLevel() 设置日志级别  
Logger.addHandler() 和 Logger.removeHandler() 添加和删除一个Handler  
Logger.addFilter() 添加一个Filter,过滤作用  
Logging.Handler：Handler基于日志级别对日志进行分发，如设置为WARNING级别的Handler只会处理WARNING及以上级别的日志。  
常用函数有：  
setLevel() 设置级别  
setFormatter() 设置Formatter

## 日志输出-控制台 ##

import logging  # 引入logging模块
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')  
                        # logging.basicConfig函数对日志的输出格式及方式做相关配置
    # 由于日志基本配置中级别设置为DEBUG，所以以下打印信息将会全部显示在控制台上
    logging.info('this is a loggging info message')
    logging.debug('this is a loggging debug message')
    logging.warning('this is loggging a warning message')
    logging.error('this is an loggging error message')
    logging.critical('this is a loggging critical message')

上面代码通过logging.basicConfig函数进行配置了日志级别和日志内容输出格式；因为级别为DEBUG，所以会将DEBUG级别以上的信息都输出显示再控制台上。  
![在这里插入图片描述][20200901221220290.png_pic_center]

## 日志输出-文件 ##

import logging
    logging.basicConfig(filename='example.log',level=logging.DEBUG)
    logging.debug('This message should go to the log file')
    logging.info('So should this')
    logging.warning('And this, too')

常见的情况是将日志记录事件记录在文件中。 上面就是一种简单地将日志输出到文件的方法。  
![在这里插入图片描述][20200902201213422.png_pic_center]  
通过basicConfig设置日志记录级别阈值

# assuming loglevel is bound to the string value obtained from the
    # command line argument. Convert to upper case to allow the user to
    # specify --log=DEBUG or --log=debug
    numeric_level = getattr(logging, loglevel.upper(), None)
    if not isinstance(numeric_level, int):
        raise ValueError('Invalid log level: %s' % loglevel)
    logging.basicConfig(level=numeric_level, ...)

对basicConfig的调用应先于对debug，info等的任何调用。由于它是一次性的简单配置工具，因此实际上只有第一个调用会做任何事情：后续调用实际上是无操作。如果您多次运行上述脚本，则连续运行的消息将附加到文件example.log中。 如果您希望每个运行重新开始，而不记得先前运行的消息，则可以通过将上述示例中的调用更改为以下方式来指定filemode参数：logging.basicConfig(filename=‘example.log’, filemode=‘w’, level=logging.DEBUG)  
输出将与以前相同，但是不再将日志文件附加到该文件，因此先前运行的消息将丢失。

import logging  # 引入logging模块
    import os.path
    import time
    # 第一步，创建一个logger
    logger = logging.getLogger()
    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')

![在这里插入图片描述][20200901221652658.png_pic_center]

## 日志输出-控制台和文件 ##

只要在输入到日志中的第二步和第三步插入一个handler输出到控制台：  
创建一个handler，用于输出到控制台  
ch = logging.StreamHandler()  
ch.setLevel(logging.WARNING) \# 输出到console的log等级的开关  
第四步和第五步分别加入以下代码即可  
ch.setFormatter(formatter)  
logger.addHandler(ch)

## 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: 打印日志信息

## 捕捉异常,用traceback记录 ##

import os.path
    import time
    import logging
    # 创建一个logger
    logger = logging.getLogger()
    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.addHandler(fh)
    # 使用logger.XX来记录错误,这里的"error"可以根据所需要的级别进行修改
    try:
        open('/path/to/does/not/exist', 'rb')
    except (SystemExit, KeyboardInterrupt):
        raise
    except Exception, e:
        logger.error('Failed to open file', exc_info=True)

![在这里插入图片描述][20200901221959842.png_pic_center]  
如果需要将日志不上报错误，仅记录，可以将exc\_info=False  
![在这里插入图片描述][20200901222102983.png_pic_center]

## 多模块调用logging,日志输出顺序 ##

warning_output.py
    import logging
    def write_warning():
        logging.warning(u"记录文件warning_output.py的日志")
    
    error_output.py
    import logging
    def write_error():
        logging.error(u"记录文件error_output.py的日志")
    
    main.py
    import logging
    import warning_output
    import error_output
    def write_critical():
        logging.critical(u"记录文件main.py的日志")
    warning_output.write_warning()  # 调用warning_output文件中write_warning方法
    write_critical()
    error_output.write_error()  # 调用error_output文件中write_error方法

![在这里插入图片描述][20200901222242574.png_pic_center]  
从上面来看，日志的输出顺序和模块执行顺序是一致的。

## 日志滚动和过期删除(按时间) ##

# coding:utf-8
    import logging
    import time
    import re
    from logging.handlers import TimedRotatingFileHandler
    from logging.handlers import RotatingFileHandler
    def backroll():
        #日志打印格式
        log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
        formatter = logging.Formatter(log_fmt)
        #创建TimedRotatingFileHandler对象
        log_file_handler = TimedRotatingFileHandler(filename="ds_update", when="M", interval=2, backupCount=2)
        #log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
        #log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
        log_file_handler.setFormatter(formatter)
        logging.basicConfig(level=logging.INFO)
        log = logging.getLogger()
        log.addHandler(log_file_handler)
        #循环打印日志
        log_content = "test log"
        count = 0
        while count < 30:
            log.error(log_content)
            time.sleep(20)
            count = count + 1
        log.removeHandler(log_file_handler)
    if __name__ == "__main__":
        backroll()

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: 表示日志文件的保留个数

## 将变量值放入记录 ##

要记录变量数据，请为事件描述消息使用格式字符串，并将变量数据附加为参数。 例如：

import logging
    logging.warning('%s before you %s', 'Look', 'leap!')

WARNING:root:Look before you leap!  
如您所见，将变量数据合并到事件描述消息中将使用％样式的字符串格式。 这是为了向后兼容：日志记录包将更新格式选项，例如str.format()和string.Template。 支持这些较新的格式设置选项，但是对它们的探索不在本教程的范围之内：有关更多信息，请参见在整个应用程序中使用特定的格式设置样式。

## 改变显示信息的格式 ##

要更改用于显示消息的格式，您需要指定要使用的格式：

import logging
    logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
    logging.debug('This message should appear on the console')
    logging.info('So should this')
    logging.warning('And this, too')

打印信息：  
DEBUG:This message should appear on the console  
INFO:So should this  
WARNING:And this, too  
请注意，先前示例中出现的root已消失。 对于可能以格式字符串显示的所有内容，可以参考LogRecord属性的文档，但是为了简单使用，您只需要级别名称（严重性），消息（事件描述，包括变量数据）并可能需要显示事件发生的时间。 下一节将对此进行描述。

## 在信息中显示日期、时间 ##

要显示事件的日期和时间，请在格式字符串中放入“％(asctime)s”：

import logging
    logging.basicConfig(format='%(asctime)s %(message)s')
    logging.warning('is when this event was logged.')

打印信息：2010-12-12 11:41:42,612 is when this event was logged.  
日期/时间显示的默认格式（如上所示）类似于ISO8601或RFC3339。如果需要对日期/时间的格式进行更多控制，请为basicConfig提供datefmt参数，如以下示例所示：

import logging
    logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
    logging.warning('is when this event was logged.')

打印信息：12/12/2010 11:46:36 AM is when this event was logged.

参考：https://docs.python.org/3/library/logging.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/52083abc2dec45e286c56cc4719f0053.png
[2020090121594168.png_pic_center]: /images/20221123/b8e126c9d3c846ffa8d1820199ddc6e7.png
[20200901220608479.png_pic_center]: /images/20221123/5bafc20b65f542d19b4b35440aec3498.png
[20200901221220290.png_pic_center]: /images/20221123/810a491ce0454d94a317bb45c6b53ed1.png
[20200902201213422.png_pic_center]: /images/20221123/b95d6aea61fe4384ac283e5e94c8e191.png
[20200901221652658.png_pic_center]: /images/20221123/45549da400ad4fc7900a37d1aa128fb5.png
[20200901221959842.png_pic_center]: /images/20221123/6b6ba1f4190940d693250e3cb08d6ac9.png
[20200901222102983.png_pic_center]: /images/20221123/e971a1b500e4477f91baf3629c564765.png
[20200901222242574.png_pic_center]: /images/20221123/0afb9113bcac4a85af81055d9cde9334.png