Python 日志模块logging

已于 2023-10-07 10:33:42 修改
阅读量3k 收藏 20
点赞数 4
分类专栏： # Python模块和包 文章标签： python 开发语言 后端 logging 日志
于 2022-02-18 17:28:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuelai_217/article/details/123008033
版权
本文详细介绍了Python中的logging模块，包括日志的基本概念、日志等级、Logger对象、处理器对象、格式器对象和Filter对象的功能。通过代码示例展示了如何将日志输出到控制台、文件，以及如何实现日志滚动和过期删除。同时，文中还提及了大型工程中使用配置文件管理日志的方式。
摘要由CSDN通过智能技术生成

文章目录

一、日志相关知识

1.1、什么是日志

日志是一种可以追踪某些软件运行时所发生事件的方法。软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情。一个事件可以用一个可包含可选变量数据的消息来描述。此外，事件也有重要性的概念，这个重要性也可以被称为严重性级别（level）。

1.2、日志的等级

级别何时使用
DEBUG详细信息，典型地调试问题时会感兴趣。 详细的debug信息。
INFO证明事情按预期工作。 关键事件。
WARNING表明发生了一些意外，或者不久的将来会发生问题（如‘磁盘满了’）。软件还是在正常工作。
ERROR由于更严重的问题，软件已不能执行一些功能了。 一般错误消息。
CRITICAL严重错误，表明软件已不能继续运行了。
NOTICE不是错误，但是可能需要处理。普通但是重要的事件。
ALERT需要立即修复，例如系统数据库损坏。
EMERGENCY紧急情况，系统不可用（例如系统崩溃），一般会通知所有用户。

二、logging 功能

2.1、功能描述

记录器暴露了应用程序代码直接使用的接口。
处理程序将日志记录（由记录器创建）发送到适当的目标。
过滤器提供了更精细的附加功能，用于确定要输出的日志记录。
格式化程序指定最终输出中日志记录的样式。

2.2、 Logger 对象常见属性

1、Logger.setLevel(level)
# 设置日志级别
2、Logger.debug(msg, *args, **kwargs)
# 在此记录器上记录 debug 级别的消息
3、Logger.info(msg, *args, **kwargs)
# 在此记录器上记录 info 级别的消息
4、Logger.warning(msg, *args, **kwargs)
# 在此记录器上记录 warning 级别的消息
5、Logger.error(msg, *args, **kwargs)
# 在此记录器上记录 error 级别的消息
6、Logger.critical(msg, *args, **kwargs)
# 在此记录器上记录 critical 级别的消息
7、Logger.log(lvl, msg, *args, **kwargs)
# 在此记录器上记录 lvl 级别的消息
8、Logger.exception(msg, *args, **kwargs)
# 以ERROR级别记录日志消息，异常跟踪信息将被自动添加到日志消息里。Logger.exception通过用在异常处理块中，如

import logging
import os

logging.basicConfig(filename=os.path.join(os.getcwd(), 'log.txt'), level=logging.DEBUG)
log = logging.getLogger('root')
try:
    raise Exception, 'this is a exception'
except:
    log.exception('exception')  # 异常信息被自动添加到日志消息中
  
9、Logger.addFilter(filter)
# 将指定的过滤器 filter 添加到此记录器。
10、Logger.removeFilter(filter)
# 从此记录器中删除指定的处理程序 filter。
11、Logger.addHandler(hdlr)
# 将指定的处理程序 hdlr 添加到此记录器。
12、Logger.removeHandler(hdlr)
# 从此记录器中删除指定的处理器 hdlr。

2.3、logging的日志等级

日志等级（level）数字值描述
DEBUG10最详细的日志信息，典型应用场景是 问题诊断
INFO20信息详细程度仅次于DEBUG，通常只记录关键节点信息，用于确认一切都是按照我们预期的那样进行工作
WARNING30当某些不期望的事情发生时记录的信息（如，磁盘可用空间较低），但是此时应用程序还是正常运行的
ERROR40由于一个更严重的问题导致某些功能不能正常运行时记录的信息
CRITICAL50当发生严重错误，导致应用程序不能继续运行时记录的信息

该列表中的日志等级是从上到下依次增高，日志内容依次减少，即DEBUG可以显示所有日志，CRITICAL只能显示自己。

默认等级是WARNING，这意味着仅仅这个等级及以上的才会反馈信息，除非logging模块被用来做其它事情。

被跟踪的事件能以不同的方式被处理。最简单的处理方法就是把它们在控制台上打印出来。另一种常见的方法就是写入磁盘文件

在Python中，print也可以输入日志，logging相对print来说更好控制输出在哪个地方，怎么输出及控制消息级别来过滤掉那些不需要的信息

2.4、处理器对象

处理器类型：

1、StreamHandler
# 将日志记录输出到sys.stdout,sys.stderr或任何类似文件流的对象，例如控制台
2、FileHandler
# 将日志输出发送到磁盘文件，它继承了StreamHandler的输出功能
logging.BasicConfig(filename="runlog.log",level=logging.DEBUG)
3、NullHandler
# 不做任何格式化输出，本质上是开发人员使用的"无操作"处理程序

Handler 有以下属性和方法。注意不要直接实例化 Handler ；这个类用来派生其他更有用的子类。但是，子类的 __init__() 方法需要调用 Handler.__init__() 。

1、Handler.__init__(level=NOTSET)
# 初始化 Handler 实例时，需要设置它的级别，将过滤列表置为空，并且创建锁（通过 createLock() ）来序列化对 I/O 的访问。
2、Handler.createLock()
# 初始化一个线程锁，用来序列化对底层的 I/O 功能的访问，底层的 I/O 功能可能不是线程安全的。
3、Handler.acquire()
# 使用 acquire() 获取线程锁。
4、Handler.release()
# 使用 release() 来释放线程锁。
5、Handler.setLevel(level)
# 给处理器设置阈值为 level 。日志级别小于 level 将被忽略。创建处理器时，日志级别被设置为 NOTSET （所有的消息都会被处理）。参见 日志级别 级别列表。
6、Handler.setFormatter(fmt)
# 将此处理器的 Formatter 设置为 fmt。
7、Handler.addFilter(filter)
# 将指定的过滤器 filter 添加到此处理器。
8、Handler.removeFilter(filter)
# 从此处理器中删除指定的过滤器 filter 。
9、Handler.flush()
# 确保所有日志记录从缓存输出。此版本不执行任何操作，并且应由子类实现。
11、Handler.close()
# 整理处理器使用的所有资源。此版本不输出，但从内部处理器列表中删除处理器，内部处理器在 shutdown() 被调用时关闭 。子类应确保从重写的 close() 方法中调用此方法。
12、Handler.handle(record)
# 经已添加到处理器的过滤器过滤后，有条件地发出指定的日志记录。用获取/释放 I/O 线程锁包装记录的实际发出行为。
13、Handler.handleError(record)
# 调用 emit() 期间遇到异常时，应从处理器中调用此方法。如果模块级属性 raiseExceptions 是 False，则异常将被静默忽略。这是大多数情况下日志系统需要的 —— 大多数用户不会关心日志系统中的错误，他们对应用程序错误更感兴趣。但是，你可以根据需要将其替换为自定义处理器。指定的记录是发生异常时正在处理的记录。（raiseExceptions 的默认值是 True，因为这在开发过程中是比较有用的）。
14、Handler.format(record)
# 如果设置了格式器则用其对记录进行格式化。否则，使用模块的默认格式器。
15、Handler.emit(record)
# 执行实际记录给定日志记录所需的操作。这个版本应由子类实现，因此这里直接引发 NotImplementedError 异常。

有关作为标准随附的处理程序，请参见 logging.handlers。

16、logging.handlers.RotatingFileHandler -> 按照大小自动分割日志文件，一旦达到指定的大小重新生成文件 
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler一样。
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。


17、logging.handlers.TimedRotatingFileHandler  -> 按照时间自动分割日志文件 
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时代表星期一）
midnight 每天凌晨

2.5、格式器对象

Formatter 对象拥有以下的属性和方法。一般情况下，它们负责将 LogRecord 转换为可由人或外部系统解释的字符串。基础的 Formatter 允许指定格式字符串。如果未提供任何值，则使用默认值 '%(message)s' ，它仅将消息包括在日志记录调用中

属性格式描述
asctime%(asctime)s日志产生的时间，默认格式为msecs2003-07-0816:49:45,896
msecs%(msecs)d日志生成时间的亳秒部分
created%(created)ftime.tme)生成的日志创建时间戳
message%(message)s具体的日志信息
filename%(filename)s生成日志的程序名
name%(name)s日志调用者
funcname%( funcname)s调用日志的函数名
levelname%(levelname)s日志级別( DEBUG,INFO, WARNING, 'ERRORCRITICAL)
levene%( leveling)s日志级别对应的数值
lineno%(lineno)d日志所针对的代码行号（如果可用的话）
module%( module)s生成日志的模块名
pathname%( pathname)s生成日志的文件的完整路径
process%( (process)d生成日志的进程D（如果可用）
processname(processname)s进程名（如果可用）
thread%(thread)d生成日志的线程D（如果可用）
threadname%( threadname)s线程名（如果可用)

2.6、Filter 对象

https://www.cnblogs.com/munan-zhou/articles/8870194.html

https://docs.python.org/zh-cn/2.7/howto/logging-cookbook.html#filters-contextual

三、代码实现

3.1、输出到控制台

import logging  

# logging.basicConfig函数对日志的输出格式及方式做相关配置
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')  

# 由于日志基本配置中级别设置为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')

3.2、输出到文件

import 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')

3.3、输出到控制台和文件中

import logging
from logging import handlers

class Logger(object):
    level_relations = {
        'debug':logging.DEBUG,
        'info':logging.INFO,
        'warning':logging.WARNING,
        'error':logging.ERROR,
        'crit':logging.CRITICAL
    }#日志级别关系映射

    def __init__(self,filename,level='info',when='D',backCount=3,fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
        self.logger = logging.getLogger(filename)
        format_str = logging.Formatter(fmt)#设置日志格式
        self.logger.setLevel(self.level_relations.get(level))#设置日志级别
        sh = logging.StreamHandler()#往屏幕上输出
        sh.setFormatter(format_str) #设置屏幕上显示的格式
        th = handlers.TimedRotatingFileHandler(filename=filename,when=when,backupCount=backCount,encoding='utf-8')#往文件里写入#指定间隔时间自动生成文件的处理器
        #实例化TimedRotatingFileHandler
        #interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
        # S 秒
        # M 分
        # H 小时、
        # D 天、
        # W 每星期（interval==0时代表星期一）
        # midnight 每天凌晨
        th.setFormatter(format_str)#设置文件里写入的格式
        self.logger.addHandler(sh) #把对象加到logger里
        self.logger.addHandler(th)
if __name__ == '__main__':
    log = Logger('all.log',level='debug')
    log.logger.debug('debug')
    log.logger.info('info')
    log.logger.warning('警告')
    log.logger.error('报错')
    log.logger.critical('严重')
    Logger('error.log', level='error').logger.error('error')

3.4、捕捉异常,用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)

3.5、日志滚动和过期删除(按时间）

# 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()

3.6、大型工程的配置文件

#./logging.conf

#记录器：提供应用程序代码直接使用的接口
#设置记录器名称，root必须存在！！！
[loggers]
keys=root,applog

#处理器，将记录器产生的日志发送至目的地
#设置处理器类型
[handlers]
keys=fileHandler,consoleHandler

#格式化器，设置日志内容的组成结构和消息字段
#设置格式化器的种类
[formatters]
keys=simpleFormatter

#设置记录器root的级别与种类
[logger_root]
level=DEBUG
handlers=consoleHandler

#设置记录器applog的级别与种类
[logger_applog]
level=DEBUG 
handlers=fileHandler,consoleHandler
#起个对外的名字
qualname=applog
#继承关系
propagate=0

#设置
[handler_consoleHandler]
class=StreamHandler
args=(sys.stdout,)
level=DEBUG
formatter=simpleFormatter

[handler_fileHandler]
class=handlers.TimedRotatingFileHandler
#在午夜1点开启下一个log文件，保留0个历史文件
args=('applog.log','midnight',1,0)
level=DEBUG
formatter=simpleFormatter

[formatter_simpleFormatter]
format=%(asctime)s|%(levelname)8s|%(filename)s[:%(lineno)d]|%(message)s
#设置时间输出格式
datefmt=%Y-%m-%d %H:%M:%S

import logging
import logging.config

logging.config.fileConfig('logging.conf')
#使用字典就能从任意格式文件进行配置，字典是一种接口格式
# logging.config.dictConfig({"loggers":"root,applog"})

rootLogger = logging.getLogger('applog')
rootLogger.debug("This is root Logger, debug")

logger = logging.getLogger('cn.cccb.applog')
logger.debug("This is applog, debug")

try:
    int(a)
except Exception as e:
    logger.exception(e)

使用方式:

1）前面的logger.conf

2）写一个get_logging.py

#get_logging.py
import logging
import logging.config

def getLogging(confName = "applog"):
    logging.config.fileConfig("logging.conf")
    return logging.getLogger(confName)

3）引用

from get_logging import getLogging
logger = getLogging()

4）输出

>>> 2021-04-26 11:23:05|   DEBUG|try.py[:21]|This is root Logger, debug
>>> 2021-04-26 11:23:05|   DEBUG|try.py[:24]|This is applog, debug
>>> 2021-04-26 11:23:05|   ERROR|try.py[:29]|name 'a' is not defined
Traceback (most recent call last):
  File "/home/kangshuaibo/code/shapan/calibration/try.py", line 27, in <module>
    int(a)
NameError: name 'a' is not defined

四、参考文档

1、https://docs.python.org/zh-cn/2.7/library/logging.html#

2、https://www.cnblogs.com/nancyzhu/p/8551506.html

3、https://www.cnblogs.com/xianyulouie/p/11041777.html

4、https://www.cnblogs.com/wkfvawl/p/14951133.html

5、https://www.cnblogs.com/munan-zhou/articles/8870194.html

岳来
关注
专栏目录
Python常用模块 之 logging：日志模块
孤寒者的博客
08-02 16万+
目录????0.引言：1.Logging模块第一阶段——基本使用！1.简介：2.日志等级：3.formater格式：4.日志等级&format格式模拟使用：5.日志信息保存为文件：第二阶段——进阶版操作！1.logging模块还提供了模块化组件的方法——灵活配置日志器：2.模块化组件使用：（1）使用步骤：（2）实战使用一（一个日志记录器对应一个日志处理器）：（3）实战使用二（一个日志记录器对应多[此处是两个]个日志处理器）：2.In The End！ ????0.引言： ????????相信很多初
Python日志模块详解
小小程序猿
09-06 1184
Python的日志模块（logging）是一个非常强大、灵活的日志记录框架，适用于各种规模的应用程序。它允许开发者将程序执行中的信息输出到多个地方，如控制台、文件、网络等。接下来我们来详细介绍它的功能和使用方法。
Python中日志模块 logging 的使用，模块处理流程和相关类及常用方法
巫山♔
07-26 1066
LOG 日志相关概念 日志 日志是一种可以追踪某些软件运行时所发生事件的方法。软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情。一个事件可以用一个可包含可选变量数据的消息来描述。此外，事件也有重要性的概念，这个重要性也可以被称为严重性级别（level）。 日志的级别 不同的用户关注不同的程序信息 DEBUG INFO NOTICE WARNING ERROR ...
python3 logging入门
u010674101的专栏
08-30 1120
通过从基础的开始，逐步掌握LoggerHandlerFormatter等核心概念，再到高级特性如日志轮转、自定义处理器，你可以构建灵活、高效的日志系统，适用于各种规模的 Python 应用。
Python logging模块详解
热门推荐
刀刀的专栏
05-06 13万+
简单将日志打印到屏幕： import logging logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message')输出： WARNI
Python的Logging模块
m0_60981735的博客
07-03 1万+
万字长文带你学透Python的Logging模块，文章通俗易懂且带有相关代码演示，具体案例助你理解
Python中logging模块
半夏微凉的博客
03-16 1411
大家在写代码的时候，经常会使用print打印日志方便排查问题，然而print的问题就是太过简单，缺少时间、日志级别等格式化信息。 Python自带的logging模块，很简单就能实现日志的配置和打印，它有两种用法，方法1是把日志输出到标准输出，其实就是命令行界面，方法2则是输出日志到文件，更加方便。 方法1：配置并输出日志到标准输出 该种方法的输出方式类似于print，不同之处在于可以设置各种输出格式，如打印时间等。 import logging LOG_FORMAT = "%(asctime)s - %
Python的logging模块
最新发布
KIKI3666的博客
09-21 1182
DEBUG: 详细信息，通常只在调试问题时使用。INFO: 确认一切按预期运行。WARNING: 指示可能出现的问题，但仍可继续运行。ERROR: 由于更严重的问题，某些功能无法执行。CRITICAL: 严重错误，程序可能无法继续运行。
Python日志模块logging简介
09-22
在Python编程中，日志模块`logging`是一个强大的工具，用于记录程序运行过程中的信息，帮助开发者追踪错误、调试程序以及监控系统状态。下面我们将详细探讨`logging`模块的各个组成部分以及如何进行配置管理。 1. *...
Python日志模块logging基本用法分析
12-24
本文实例讲述了Python日志模块logging基本用法。分享给大家供大家参考，具体如下： 1. 基础用法 python提供了一个标准的日志接口，就是logging模块。日志级别有DEBUG、INFO、WARNING、ERROR、CRITICAL五种（级别依次...
Python logging 模块
灰蓝
09-06 7681
Python logging 模块 给大家剖析下Python的logging模块。 logging模块是Python内置的一个强大易用的日志模块。简单到你只需要两行代码就能输出一些东西来：import logging logging.warning('Hi, I print something.')输出：WARNING:root:Hi, I print something.当然，我们可不能满足于
python中的logging模块
Gelsey1的博客
01-07 6543
一 日志 1.定义：跟踪 软件运行时产生的事件的方法（跟踪器） 2. 作用：1 调试程序，定位问题 ，2.数据分析， 3. 用户信息跟踪 二 如何实现日志收集 1. python中的内置模块 logging 2. logging模块的基本应用：四大组件 1. 日志器 logger 给所有的应用程序提供入口 2. 处理器 handler 决定在不同端实现输出 3. 格式器 formater 决定日志内容（日志包含事件，行号，信息描述，信息级别......信息） ...
python——日志模块
lhl0306的博客
07-01 1609
日志主要用于记录程序运行情况，以便程序报错能够快速定位到问题。Python自带日志操作模块，即logging模块。
python——日志模块（logging）
黑砂的博客
03-02 2712
python——日志模块（logging
Python模块：log日志模块
不愿意透露姓名的网友
08-03 8200
函数说明创建一条严重级别为DEBUG的日志记录创建一条严重级别为INFO的日志记录创建一条严重级别为WARNING的日志记录创建一条严重级别为ERROR的日志记录创建一条严重级别为CRITICAL的日志记录创建一条严重级别为level的日志记录对root logger进行一次性配置注意：basicConfig函数用于指定“要记录的日志级别”、“日志格式”、“日志输出位置”、“日志文件的打开模式”等信息，其他几个都是用于记录各个级别日志的函数。组件说明loggers。
python学习——Python中的logging模块
geerniya的博客
04-17 552
最近修改了项目里的logging相关功能，用到了python标准库里的logging模块，在此做一些记录。主要是从官方文档和stackoverflow上查询到的一些内容。 基本用法 下面的代码展示了logging最基本的用法。 # -*- coding: utf-8 -*- import logging import sys # 获取logger实例，如果参数为空则返回root lo...
Python logging 模块详解
曹立禄的个人博客
06-06 1369
Python 的logging模块提供了一个强大而灵活的日志系统。它是 Python 标准库的一部分，因此可以在任何 Python 程序中使用。logging模块提供了许多有用的功能，包括日志消息的级别设置、日志消息的格式设置、将日志消息输出到不同的目标，以及处理复杂的日志系统配置。
Python中的logging模块
木盏
05-22 1539
logging是Python中常见的日志工具，能够把一次运行的关键信息记录成日志，以便debug。为了让读者更快掌握这个工具，咱们逐步深入.
logging日志（Python版）
baidu_33094261的博客
04-02 483
logging日志 logging日志的介绍 在现实生活中，记录日志非常重要，比如:银行转账时会有转账记录；飞机飞行过程中，会有个黑盒子（飞行数据记录器）记录着飞机的飞行过程，那在咱们python程序中想要记录程序在运行时所产生的日志信息，怎么做呢? 可以使用 logging 这个包来完成 记录程序日志信息的目的是: 可以很方便的了解程序的运行情况 可以分析用户的操作行为、喜好等信息 方便开发人员检查bug 2. logging日志级别介绍 日志等级可以分为5个，从低到高分别是: DEBUG INFO
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值