【接口测试】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.级别("想要输出的信息")

相关推荐
.又是新的一天.1 天前
AI接口测试03（操作数据库/管理文档/mock/自动化测试/定时任务/AI导师）
软件测试·测试工具·接口测试·apifox
欢醉4 天前
基于日志的监控告警：我们是怎么用一套轻量方案把线上问题"盯"住的
elasticsearch·springcloud·日志
SelectDB技术团队12 天前
一条日志两套引擎的账：把 Elasticsearch 检索与分析合并到同一份数据的落地写法
大数据·数据库·elasticsearch·搜索引擎·全文检索·日志·apache doris
SelectDB技术团队12 天前
Apache Doris 高性能 Open Lake Variant 读写技术解析（含对比数据）
数据结构·数据库·clickhouse·日志·apache doris·selectdb·湖仓架构升级
阿蔹14 天前
TestHub智能测试管理平台框架介绍
自动化·接口测试·测试·测试平台
更深兼春远22 天前
Python到底怎么用于测试？
自动化测试·软件测试·python·接口测试
小乙说23 天前
JMeter接口测试
jmeter·接口测试
测试老哥1 个月前
接口测试的测试用例应该怎么写？
自动化测试·软件测试·python·测试工具·职场和发展·测试用例·接口测试
测试19981 个月前
Jmeter接口自动化测试：Jmeter变量的使用
自动化测试·软件测试·测试工具·jmeter·职场和发展·测试用例·接口测试
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03如何新建文件夹？ 电脑新建文件夹的4种方法04「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会05GitHub 镜像站点06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地08Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）09Telegram APK 下载安装完整指南 — 2026年最新10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新