【接口测试】7_代码实现 _日志收集

少云清2025-12-26 8:40

文章目录

  • 一、日志简介
    • [1.1 日志级别](#1.1 日志级别)
    • [1.2 日志级别-总结](#1.2 日志级别-总结)
  • 二、日志的基本方法-logging模块
    • [2.1 logging模块-基本用法](#2.1 logging模块-基本用法)
    • [2.2 设置日志级别](#2.2 设置日志级别)
    • [2.3 设置日志格式](#2.3 设置日志格式)
    • [2.4 将日志信息输出到文件中](#2.4 将日志信息输出到文件中)
    • [2.5 基本方法-总结](#2.5 基本方法-总结)
  • 三、日志的高级方法
    • [3.1 logging日志模块四大组件](#3.1 logging日志模块四大组件)
      • [3.1.1 组件之间的关系](#3.1.1 组件之间的关系)
    • [3.2 ① Logger类](#3.2 ① Logger类)
      • [3.2.1 Logger对象的任务](#3.2.1 Logger对象的任务)
      • [3.2.2 创建Logger对象](#3.2.2 创建Logger对象)
      • [3.2.3 Logger常用的方法](#3.2.3 Logger常用的方法)
      • [3.2.4 Logger-案例](#3.2.4 Logger-案例)
    • [3.3 ② Handler类](#3.3 ② Handler类)
      • [3.3.1 创建Handler对象](#3.3.1 创建Handler对象)
      • [3.3.2 Handler常用的方法](#3.3.2 Handler常用的方法)
      • [3.3.3 Handler-将日志信息同时输出到控制台和文件中](#3.3.3 Handler-将日志信息同时输出到控制台和文件中)
    • [3.4 ③ Formatter类](#3.4 ③ Formatter类)
      • [3.4.1 创建Formatter对象](#3.4.1 创建Formatter对象)
      • [3.4.1 Formatter-将日志信息同时输出到控制台和文件中](#3.4.1 Formatter-将日志信息同时输出到控制台和文件中)
    • [3.5 高级用法-总结](#3.5 高级用法-总结)
  • 四、每秒生成一个日志文件-案例
  • 五、将只有error级别错误信息写入文件
  • 六、使用单例封装logger日志对象
    • [6.1 日志封装-总结](#6.1 日志封装-总结)
  • 七、日志代码实现分析
  • 八、项目中日志使用步骤

一、日志简介

1、什么是日志

  • 日志也叫 Log。用来记录系统在运行过程中，产生的信息（变量值、参数、响应结果、错误、异常）。保存到 xxx.log 文件中。

2、搜集日志的作用

  • 分析代码，定位bug。
  • 调试代码。
  • 了解系统运行的状态。
  • 分析用户行为，做数据统计。

1.1 日志级别

日志级别： 是指日志信息的优先级、 重要性或者严重程度

日志级别 描述
DEBUG 调试级别， 打印非常详细的日志信息， 通常用于对代码的调试
INFO 信息级别， 打印一般的日志信息， 突出强调程序的运行过程
WARNING 警告级别， 打印警告日志信息， 表明会出现潜在错误的情形， 一般不影响软件的正常使用
ERROR 错误级别， 打印错误异常信息， 该级别的错误可能会导致系统的一些功能无法正常使用
CRITICAL 严重错误级别， 一个严重的错误， 这表明系统可能无法继续运行

说明：

  • 上面列表中的日志级别是从上到下依次升高的， 即： DEBUG < INFO < WARNING < ERROR < CRITICAL；
  • 当为程序设置一个日志级别后， 程序会记录所有日志级别大于或等于指定日志级别的日志信息， 而不是仅仅记录指定级别的日志信息；
  • 一般建议只使用DEBUG、 INFO、 WARNING、 ERROR这四个级别

1.2 日志级别-总结

python 复制代码 
1.1 什么是日志
	说明：记录系统运行程序一些步骤，对一个事件(点击事件)也称为日志(Log)
1.2 特点
	1. 调试程序
	2. 定位跟踪bug
	3. 根据日志，查看系统运行是否出错；
	4. 分析用户行为，与数据统计
1.3 级别
	1. debug # 调试级别
	2. info  # 信息级别
	3. warning # 警告
	4. error # 错误级别
	5. critical # 严重
	
	提示：
		1. 开发常用以上 debug、info、warning、error
		2. 测试常用级别：info、error

二、日志的基本方法-logging模块

Python中有一个标准库模块logging可以直接记录日志

2.1 logging模块-基本用法

python 复制代码 
import logging
logging.debug("这是一条调试信息")
logging.info("这是一条普通信息")
logging.warning("这是一条警告信息")
logging.error("这是一条错误信息")
logging.critical("这是一条严重错误信息")

2.2 设置日志级别

logging中默认的日志级别为WARNING， 程序中大于等于该级别的日志才能输出， 小于该级别的日志不会被打印出来。

python 复制代码 
# 导包
import logging

# 设置日志级别
logging.basicConfig(level=logging.DEBUG)

如何选择日志级别：

  • 在开发环境和测试环境中， 为了尽可能详细的查看程序的运行状态来保证上线后的稳定性， 可以使用DEBUG或INFO级别的日志获取详细的日志信息， 这是非常耗费机器性能的。
  • 在生产环境中， 通常只记录程序的异常信息、 错误信息等（设置成WARNING或ERROR级别） ， 这样既可以减小服务器的I/O压力， 也可以提高获取错误日志信息的效率和方便问题的排查。

2.3 设置日志格式

默认的日志的格式为---日志级别:Logger名称:日志内容

python 复制代码 
logging.basicConfig(format="%(levelname)s:%(name)s:%(message)s")

format参数中可能用到的格式化信息：

占位符 描述
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名， 可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间， 用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的， 自Logger创建以来的毫秒数
%(asctime)s 字符串形式的当前时间。 默认格式是 "2003-07-08 16:49:45,896"
%(thread)d 线程ID。 可能没有
%(threadName)s 线程名。 可能没有
%(process)d 进程ID。 可能没有
%(message)s 用户输出的消息
python 复制代码 
import logging

# 设置修改默认的输入日志格式
fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
logging.basicConfig(level=logging.INFO, format=fmt)

logging.debug("调试")
logging.info("信息")
logging.warning("警告")
logging.error("错误")

结果：

python 复制代码 
2024-07-04 00:17:35,026 INFO [root] [test_login.py(<module>:5)] - 信息
2024-07-04 00:17:35,026 WARNING [root] [test_login.py(<module>:6)] - 警告
2024-07-04 00:17:35,026 ERROR [root] [test_login.py(<module>:7)] - 错误

2.4 将日志信息输出到文件中

默认情况下Python的logging模块将日志打印到了标准输出中（控制台）

将日志信息输出到文件中：

python 复制代码 
logging.basicConfig(filename="a.log")

示例代码：

python 复制代码 
# 导包
import logging

# 设置修改默认的输入日志格式
fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
# 设置日志保存到指定文件中
logging.basicConfig(level=logging.DEBUG, format=fmt, filename="../log/log01.log")

# 调用 指定级别，输入日志信息
logging.debug("this is a debug...")
logging.info("this is a info...")
logging.warning("this is a warning...")
logging.error("this is a error...")
logging.critical("this is a critical...")

2.5 基本方法-总结

python 复制代码 
1.4 Logging基本使用
	步骤：
		1. 导包  如：import logging
		2. 调用相应的级别方法，记录日志信息 logging.debug("debug...")
	设置级别：
		logging.basicConfig(level=logging.DEBUG)
	提示：
		1. 默认级别为：logging.WARNING
		2. 设置级别时调用的是logging文件夹下面的常量，而不是调用的小写方法
		3. 切记：设置级别以后，日志信息只会记录大于等于此级别的信息；
	
	设置格式
		fm = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
		logging.basicConfig(level=logging.DEBUG, format=fm)
	
	设置输入到文件
		logging.basicConfig(level=logging.DEBUG, format=fm, filename="../log/log01.log")

三、日志的高级方法

3.1 logging日志模块四大组件

logging模块就是通过这些组件来完成日志处理的

组件名称 类名 功能描述
日志器 Logger 提供了程序使用日志的入口
处理器 Handler 将logger创建的日志记录发送到合适的目的输出
格式器 Formatter 决定日志记录的最终输出格式
过滤器 Filter 提供了更细粒度的控制工具来决定输出哪条日志记录， 丢弃哪条日志记录

3.1.1 组件之间的关系

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

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

3.2 ① Logger类

3.2.1 Logger对象的任务

  • 向程序暴露记录日志的方法
  • 基于日志级别或Filter对象来决定要对哪些日志进行后续处理
  • 将日志消息传送给所有感兴趣的日志handlers

3.2.2 创建Logger对象

python 复制代码 
# 1、不指定用户名，默认为root
logger = logging.getLogger()   # logging包名，包名下面的getLogger

# 2、指定用户名myLogger
logger = logging.getLogger("myLogger")

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

3.2.3 Logger常用的方法

方法 描述
logger.debug() logger.info() logger.warning() logger.error() logger.critical() 打印日志
logger.setLevel() 设置日志器将会处理的日志消息的最低严重级别
logger.addHandler() 为该logger对象添加一个handler对象
logger.addFilter() 为该logger对象添加一个filter对象

3.2.4 Logger-案例

python 复制代码 
"""
    目标： 学习 logging底层 模块实现
        1. logger
"""

import logging

# 获取logger
logger = logging.getLogger()
# 设置级别
logger.setLevel(logging.INFO)

# 获取控制台 处理器sh
sh = logging.StreamHandler()

# 将处理器sh 添加到 logger
logger.addHandler(sh)

# 输入信息
logger.info("info")
logger.debug("debug")

3.3 ② Handler类

Handler对象的作用是将消息分发到handler指定的位置， 比如： 控制台、 文件、 网络、 邮件等。 Logger对象可以通过addHandler()方法为自己添加多个handler对象。

3.3.1 创建Handler对象

在程序中不应该直接实例化和使用Handler实例， 因为Handler是一个基类， 它只定义了Handler应该有的接口。 应该使用Handler实现类来创建对象， logging中内置的常用的Handler包括：

Handler 描述
logging.StreamHandler 将日志消息发送到输出到Stream（将日志发送到控制台）， 如std.out, std.err或任何 file-like对象。
logging.FileHandler 将日志消息发送到磁盘文件， 默认情况下文件大小会无限增 长
logging.handlers.RotatingFileHandler 将日志消息发送到磁盘文件， 并支持日志文件按大小切割
logging.hanlders.TimedRotatingFileHandler 将日志消息发送到磁盘文件， 并支持日志文件按时间切割
logging.handlers.HTTPHandler 将日志消息以GET或POST的方式发送给一个HTTP服务器
logging.handlers.SMTPHandler 将日志消息发送给一个指定的email地址

3.3.2 Handler常用的方法

方法 描述
handler.setLevel() 设置handler将会处理的日志消息的最低严重级别
handler.setFormatter() 为handler设置一个格式器对象
handler.addFilter() 为handler添加一个过滤器对象

3.3.3 Handler-将日志信息同时输出到控制台和文件中

python 复制代码 
"""
    目标： 学习 logging底层 模块实现
        1. logger
"""

"""
# 注意以后导logging包，不在使用此方式
import logging
"""

# 导包时 导入 import logging.handlers 推荐：原因 logging是包名，导入包名时会自动执行包下面的__init__文件，所以这样导入，相当于导入 logging
# handlers为模块名称
import logging.handlers

# 获取logger
logger = logging.getLogger()

# 设置级别
logger.setLevel(logging.INFO)

# 获取控制台 处理器
sh = logging.StreamHandler()

# # 获取文件 处理器
th = logging.handlers.TimedRotatingFileHandler(filename="../log/logtime.log",
                                                when="S",
                                                interval=1,
                                                backupCount=3)
""""
fh = logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0)
将日志信息记录到文件中， 以特定的时间间隔切换日志文件。
filename: 日志文件名
when: 时间单位， 可选参数
S - Seconds
M - Minutes
H - Hours
D - Days
midnight - roll over at midnight
W{0-6} - roll over on a certain day; 0 - Monday
interval: 时间间隔，这里设置为1表示每秒滚动一次。
backupCount: 日志文件备份数量。 如果backupCount大于0， 那么当生成新的日志文件时，将只保留backupCount个文件， 删除最老的文件。
综上所述，这个函数的作用是创建一个按秒滚动的日志处理器，每秒将日志记录到新的文件中，并最多保留3个备份文件。
"""

# 将 控制台处理器添加到 logger日志器
logger.addHandler(sh)
# 将 文件处理器添加到 logger日志器
logger.addHandler(th)


logger.info("info")
logger.debug("debug")
logger.error("error")
logger.warning("warning")

结果：一个在控制台输出；一个以文件形式输出。

python 复制代码 
info
error
warning

3.4 ③ Formatter类

Formatter对象用于配置日志信息的格式。

3.4.1 创建Formatter对象

python 复制代码 
formatter = logging.Formatter(fmt=None, datefmt=None, style='%')

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

3.4.1 Formatter-将日志信息同时输出到控制台和文件中

实现步骤分析：

1.创建日志器对象

2.创建控制台处理器对象

3.创建文件处理器对象

4.创建格式化器对象

5.把格式化器添加到处理器中

6.把处理器添加到日志器中

python 复制代码 
"""
    目标： 学习 logging底层 模块实现
        1. logger
"""

"""
# 注意以后导logging包，不在使用此方式
import logging
"""

# 导包时 导入 import logging.handlers 推荐：原因 logging是包名，导入包名时会自动执行包下面的__init__文件，所以这样导入，相当于导入 logging
# handlers为模块名称
import logging.handlers

# 获取logger
logger = logging.getLogger()

# 设置级别
logger.setLevel(logging.INFO)

# 获取控制台 处理器
sh = logging.StreamHandler()

# 获取文件 处理器

th = logging.handlers.TimedRotatingFileHandler(filename="../log/logtime.log",
                                                when="S",
                                                interval=1,
                                                backupCount=3)
""""
fh = logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0)
将日志信息记录到文件中， 以特定的时间间隔切换日志文件。
filename: 日志文件名
when: 时间单位， 可选参数
S - Seconds
M - Minutes
H - Hours
D - Days
midnight - roll over at midnight
W{0-6} - roll over on a certain day; 0 - Monday
interval: 时间间隔，这里设置为1表示每秒滚动一次。
backupCount: 日志文件备份数量。 如果backupCount大于0， 那么当生成新的日志文件时，将只保留backupCount个文件， 删除最老的文件。
综上所述，这个函数的作用是创建一个按秒滚动的日志处理器，每秒将日志记录到新的文件中，并最多保留3个备份文件。
"""

# fmt格式字符串
fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
# 获取格式器对象
fm = logging.Formatter(fmt)

# 将格式器 添加到处理器中
sh.setFormatter(fm)
th.setFormatter(fm)


# 将 控制台处理器添加到 logger日志器
logger.addHandler(sh)
# 将 文件处理器添加到 logger日志器
logger.addHandler(th)

logger.info("info")
logger.debug("debug")
logger.error("error")
logger.warning("warning")

结果：一个在控制台输出；一个以文件形式输出。

python 复制代码 
2024-07-09 00:30:29,478 INFO [root] [test03_logger.py (<module>:56] - info
2024-07-09 00:30:29,480 ERROR [root] [test03_logger.py (<module>:58] - error
2024-07-09 00:30:29,480 WARNING [root] [test03_logger.py (<module>:59] - warning

3.5 高级用法-总结

python 复制代码 
1.5 logging 高级用法
	1). 为什么要使用高阶用法？？？
		1. 中文乱码
		2. 无法同时输入到文件和控制台
	2). logging组成
		1. Logger 日志器
		2. handler 处理器
		3. formatter 格式器
		4. filter 过滤器
	3). 模块关系
		日志器：提供了，记录日志的入口，如：log.info("")
		处理器：真正将日志器内容发送到控制台还是文件或网络，都是处理器干的；每个日志器都可以添加多个不同的处理器
		格式器：处理器可以设置不同的格式，就需要使用格式器
		过滤器：处理器需要过滤日志信息，就需要设置过滤器；
		
	日志器： 
		操作：
			1. 导包 import logging
			2. 调用方法获取logger对象 # 如： logging.getlogger()
			3. 设置级别：logger.setlevel=logging.INFO
			4. 调用添加处理器方法 logger.addHandler(处理器)
			
	处理器： 
		类型： 
			1. 控制台处理器 StreamHandler()
			2. 文件处理器 fileHandler() # 文件无限增大
			3. 根据大小切割 RotatingFileHandler() 了解
			4. 根据时间切割 TimedRotatingFileHandler() 掌握
		
		获取：
			sf = logging.StreamHandler()
			
		TimedRotatingFileHandler()应用： 
			1. 导包： import logging.handlers
			2. 实例化：th = logging.handers.TimedRotatingFileHandler(filename="日志文件保存的目录及文件名",
																	when='M',
																	interval="1",
																	backupcount=30)
				1). when：时间单位
				2). interval:时间间隔
				3). backupcount:保留的备份数量
	格式器：
		获取： 
			fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
			fm = logging.Formatter(fmt)
			
		将格式器添加到处理器中
			控制台处理器.setFormatter(fm)
			文件处理器.setFormatter(fm)
			
	应用：
		logger.info("日志信息")
		logger.error("日志信息")

四、每秒生成一个日志文件-案例

  • 1秒保存一个日志文件，总共保存3个。第4秒，会自动替换。
  • 最新的文件永远替换最老的文件
  • 一般项目中通常改为一夜：when=midnight
python 复制代码 
"""
    目标： 学习 logging底层 模块实现
        1. logger
"""

"""
# 注意以后导logging包，不在使用此方式
import logging
"""

# 导包时 导入 import logging.handlers 推荐：原因 logging是包名，导入包名时会自动执行包下面的__init__文件，所以这样导入，相当于导入 logging
# handlers为模块名称
import logging.handlers
from time import sleep

# 获取logger
logger = logging.getLogger("test")

# 设置级别
logger.setLevel(logging.INFO)

# 获取控制台 处理器
sh = logging.StreamHandler()

# 获取文件 处理器

th = logging.handlers.TimedRotatingFileHandler(filename="../log/logtime.log",
                                                when="S",
                                                interval=1,
                                                backupCount=3)
""""
fh = logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0)
将日志信息记录到文件中， 以特定的时间间隔切换日志文件。
filename: 日志文件名
when: 时间单位， 可选参数
S - Seconds
M - Minutes
H - Hours
D - Days
midnight - roll over at midnight
W{0-6} - roll over on a certain day; 0 - Monday
interval: 时间间隔，这里设置为1表示每秒滚动一次。
backupCount: 日志文件备份数量。 如果backupCount大于0， 那么当生成新的日志文件时，将只保留backupCount个文件， 删除最老的文件。
综上所述，这个函数的作用是创建一个按秒滚动的日志处理器，每秒将日志记录到新的文件中，并最多保留3个备份文件。
"""

# fmt格式字符串
fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
# 获取格式器对象
fm = logging.Formatter(fmt)

# 将格式器 添加到处理器中
sh.setFormatter(fm)
th.setFormatter(fm)


# 将 控制台处理器添加到 logger日志器
logger.addHandler(sh)
# 将 文件处理器添加到 logger日志器
logger.addHandler(th)


# 循环打印info，循环不停止
while True:
    sleep(1)
    # 输入信息
    logger.info("info")
    logger.debug("debug")

五、将只有error级别错误信息写入文件

处理器设置：设置未error级别，那么只有error级别信息才会写入文件

python 复制代码 
"""
    目标： 学习 logging底层 模块实现
        1. logger
"""

"""
# 注意以后导logging包，不在使用此方式
import logging
"""

# 导包时 导入 import logging.handlers 推荐：原因 logging是包名，导入包名时会自动执行包下面的__init__文件，所以这样导入，相当于导入 logging
# handlers为模块名称
import logging.handlers
from time import sleep

# 获取logger
logger = logging.getLogger("test")

# 设置级别
logger.setLevel(logging.INFO)

# 获取控制台 处理器
sh = logging.StreamHandler()

# 获取文件 处理器
th = logging.handlers.TimedRotatingFileHandler(filename="../log/logtime.log",
                                                when="S",
                                                interval=1,
                                                backupCount=3)
""""
fh = logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0)
将日志信息记录到文件中， 以特定的时间间隔切换日志文件。
filename: 日志文件名
when: 时间单位， 可选参数
S - Seconds
M - Minutes
H - Hours
D - Days
midnight - roll over at midnight
W{0-6} - roll over on a certain day; 0 - Monday
interval: 时间间隔，这里设置为1表示每秒滚动一次。
backupCount: 日志文件备份数量。 如果backupCount大于0， 那么当生成新的日志文件时，将只保留backupCount个文件， 删除最老的文件。
综上所述，这个函数的作用是创建一个按秒滚动的日志处理器，每秒将日志记录到新的文件中，并最多保留3个备份文件。
"""

# 设置 处理器 级别 扩展 设置未error级别，那么只有error级别信息才会写入文件
th.setLevel(logging.ERROR)

# fmt格式字符串
fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
# 获取格式器对象
fm = logging.Formatter(fmt)

# 将格式器 添加到处理器中
sh.setFormatter(fm)
th.setFormatter(fm)


# 将 控制台处理器添加到 logger日志器
logger.addHandler(sh)
# 将 文件处理器添加到 logger日志器
logger.addHandler(th)


logger.info("info")
logger.debug("debug")
logger.error("error")
logger.warning("warning")

六、使用单例封装logger日志对象

使用单例封装logger日志对象，避免日志重复

python 复制代码 
# 导包
import logging.handlers


class GetLogger:
    logger = None  # 类属性等于空

     # 类方法
    @classmethod
    def get_logger(cls):
        if cls.logger is None:  # 如果是空的时候，就设置 日志器；如果不是空，就返回None
            # 获取 日志器
            cls.logger = logging.getLogger()
            # 设置 日志器 级别
            cls.logger.setLevel(logging.INFO)

            # 获取处理器 控制台
            sh = logging.StreamHandler()
            # # 获取文件 处理器
            th = logging.handlers.TimedRotatingFileHandler(filename="../log/log02.log",
                                                           when="midnight",
                                                           interval=1,
                                                           backupCount=30,
                                                           encoding="utf-8")
            # 设置格式器
            fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
            fm = logging.Formatter(fmt)
            # 将格式器添加到 处理器 控制台  
            sh.setFormatter(fm)
            # 将格式器添加到 文件处理器
            th.setFormatter(fm)
            # 将处理器添加到 日志器
            cls.logger.addHandler(sh)
            cls.logger.addHandler(th)
        return cls.logger


if __name__ == '__main__':
    logger = GetLogger().get_logger()
    logger.info("info信息被执行")
    logger.error("error信息被执行")

结果：一个在控制台输出；一个以文件形式输出。

python 复制代码 
2024-07-11 23:50:15,172 INFO [root] [test05_logger.py (<module>:39] - info信息被执行
2024-07-11 23:50:15,174 ERROR [root] [test05_logger.py (<module>:40] - error信息被执行

6.1 日志封装-总结

python 复制代码 
日志封装
	# 定义获取日之类
		# 定义类属性 logger = None
		
		@classemethod
		# 定义获取logger日志器的类方法
			if cls.logger is None: # 判断类属性logger是否还是为空，如果为空，就执行以下操作
				# 获取 日志器对象
				# 设置日志器级别
				# 获取控制台处理器
				# 获取文件处理器
				# 获取格式器
				# 将格式器添加到处理器中
				# 将处理器添加到日志器中
			return 类属性logger
			
		注意：
			1. 以上条件无论是否成立，最后都会返回类属性logger;
			2. 当第一次调用时，条件一定成立，将类属性logger设置不为空；
			3. 当第二次以上调用时，永远返回第一次设置的类属性对象；

七、日志代码实现分析

日志代码，无需手写实现。会修改、调用即可！

python 复制代码 
"""
步骤：
# 0. 导包
# 1. 创建日志器对象
# 2. 设置日志打印级别
    # logging.DEBUG 调试级别
    # logging.INFO 信息级别
    # logging.WARNING 警告级别
    # logging.ERROR 错误级别
    # logging.CRITICAL 严重错误级别
# 3. 创建处理器对象
    # 创建 输出到控制台 处理器对象
    # 创建 输出到日志文件 处理器对象
# 4. 创建日志信息格式
# 5. 将日志信息格式设置给处理器
    # 设置给 控制台处理器
    # 设置给 日志文件处理器
# 6. 给日志器添加处理器
    # 给日志对象 添加 控制台处理器
    # 给日志对象 添加 日志文件处理器
# 7. 打印日志
"""
import logging.handlers
import logging
import time

# 1. 创建日志器对象
logger = logging.getLogger()

# 2. 设置日志打印级别
logger.setLevel(logging.DEBUG)
# logging.DEBUG 调试级别
# logging.INFO 信息级别
# logging.WARNING 警告级别
# logging.ERROR 错误级别
# logging.CRITICAL 严重错误级别

# 3.1 创建 输出到控制台 处理器对象
st = logging.StreamHandler()
# 3.2 创建 输出到日志文件 处理器对象
fh = logging.handlers.TimedRotatingFileHandler('a.log', when='midnight', interval=1,
                                               backupCount=3, encoding='utf-8')
# when 字符串，指定日志切分间隔时间的单位。midnight：凌晨：12点。
# interval 是间隔时间单位的个数，指等待多少个 when 后继续进行日志记录
# backupCount 是保留日志文件的个数

# 4. 创建日志信息格式
fmt = "%(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s"
formatter = logging.Formatter(fmt)

# 5.1 日志信息格式 设置给 控制台处理器
st.setFormatter(formatter)
# 5.2 日志信息格式 设置给 日志文件处理器
fh.setFormatter(formatter)

# 6.1 给日志器对象 添加 控制台处理器
logger.addHandler(st)
# 6.2 给日志器对象 添加 日志文件处理器
logger.addHandler(fh)

# 7. 打印日志
while True:
    # logging.debug('我是一个调试级别的日志')
    logging.info('我是一个信息级别的日志')
    # logging.warning('我是一个警告级别的日志')
    # logging.error('我是一个错误级别的日志')
    # logging.critical('我是一个严重错误级别的日志')
    time.sleep(1)

八、项目中日志使用步骤

  1. 将 loggin_use.py 文件部署到项目中。 如：拷贝至 common/ 下。

  2. 在 项目下 创建 log/ 用来存放生成的 xxx.log 日志文件

  3. 在 项目中，使用日志之前，初始化日志信息，指定 日志文件名【必填】、单位、单位间隔、保留文件个数。

  4. 在 需要打印输出的位置，使用 logging.级别("想要输出的信息")

相关推荐
陈嘿萌13 小时前
图像融合任务在目标检测中的性能评估与深度思考
目标检测·yolov8·图像融合·深度思考·代码实现
少云清18 小时前
【接口测试】4_代码实现 _pytest框架
pytest·接口测试
安冬的码畜日常20 小时前
【玩转 Postman 接口测试与开发2_020】（完结篇）DIY 实战：随书示例 API 项目本地部署保姆级搭建教程（含完整调试过程）
python·测试工具·django·接口测试·postman·fastapi·api项目
爱吃 香菜20 小时前
一文掌握接口测试三大工具：Jmeter、Postman、PyCharm
自动化测试·软件测试·测试工具·jmeter·接口测试·postman·职场经验
Wpa.wk1 天前
接口测试 - 了解接口测试和接口协议
经验分享·接口测试·接口协议
Wpa.wk1 天前
接口测试 - 接口测试用例设计
经验分享·测试用例·接口测试·postman
百度测试开发1 天前
【最细】软件测试面试项目讲解，项目经验，功能到接口到自动化...
自动化测试·软件测试·功能测试·软件测试工程师·接口测试·软件测试项目·软件测试面试
Gogo8162 天前
Node.js 生产环境避坑指南：从 PM2“麦当劳理论”到日志全链路治理
node.js·日志·pm2
百度测试开发2 天前
测试经验分享，Web自动化测试+性能测试面试项目讲解（详情）
自动化测试·软件测试·软件测试工程师·接口测试·软件测试项目·软件测试面试·性能测试
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击033D 圣诞树网页代码04UV安装并设置国内源05Linux下V2Ray安装配置指南06Gemini3 生成的基于手势控制3D粒子圣诞树07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题09开源分享 | 超浪漫 3D 圣诞树立体动画（附零基础使用教程）10GLM-4.7 vs MiniMax-M2.1：代码工程理解