【python自动化】七月PytestAutoApi开源框架学习笔记（一）

前言

本篇内容为学习七月大佬开源框架PytestAutoApi记录的相关知识点，供大家学习探讨

项目地址：https://gitee.com/yu_xiao_qi/pytest-auto-api2

阅读本文前，请先对该框架有一个整体学习，请认真阅读作者的README.md文件。

本文目录如下：

文章目录

- 前言
- ast.literal_eval()
- os.sep.join 和 os.path.join的区别
- python中def方法中加一个*号是什么意思
- python的@property
- 循环删除文件
- pytest的钩子函数
- staticmethod，classmethod，普通method有什么区别
- 关于缓存
- 关于安全读取yaml数据
- 枚举类型enum
- - 1、enum模块
  - 2、枚举类型的使用
  - 其他获枚举取值的方式：
  - 枚举值value：name的映射函数：`_value2member_map_`
- python中re.sub函数

ast.literal_eval()

参考文章：https://blog.csdn.net/xili2532/article/details/115393854

功能类似于eval，eval()官方文档里面给出来的功能解释是：将字符串string对象转化为有效的表达式参与求值运算返回计算结果，但是eval也有很大的安全隐患，比如用户输入一些恶意字符串执行操作。eval在处理空字符串时会返回EOF错误，或者语法格式问题，缺括号等等

所以这里就引出了另外一个安全处理方式ast.literal_eval.，会判断需要计算的内容计算后是不是合法的Python类型，如果是则进行运算，否则就不进行运算。从而大大降低了系统的危险性

os.sep.join 和 os.path.join的区别

os.sep.join和os.path.join都是用于拼接文件路径的方法，但是两者的作用不同。

os.sep是一个字符串常量，表示操作系统路径分隔符，如在Windows系统中为\\，在Unix系统中为/。而os.sep.join方法则是将列表或者元组中的字符串用os.sep拼接起来，形成一个路径字符串。

举个例子：

import os

path_list = ['usr', 'local', 'bin']
path_str = os.sep.join(path_list)

print(path_str)
# Unix系统中输出：usr/local/bin
# Windows系统中输出：usr\local\bin

而os.path.join方法则是根据不同操作系统的不同路径分隔符自动拼接起来路径字符串。这样就能在不同操作系统中正确拼接文件路径了。

举个例子：

import os

path_str = os.path.join('usr', 'local', 'bin')

print(path_str)
# Unix系统中输出：usr/local/bin
# Windows系统中输出：usr\local\bin

因此，如果要拼接路径，推荐使用os.path.join方法，这样能保证代码的可移植性。而os.sep.join方法更适合在拼接路径中需要自定义路径分隔符的情况下使用。

python中def方法中加一个*号是什么意思

在 Python 的函数定义中，*args 和 **kwargs 分别表示接收可变数量的位置参数和关键字参数。当在函数定义时，使用单个 * 作为形参前缀时，表示接收可变数量的位置参数，而使用双星号 ** 前缀时，表示接收可变数量的关键字参数。

当在函数调用时，使用单个星号 * 作为实参前缀时，表示将一个可迭代对象（比如一个列表或元组）拆分成独立的位置参数，而使用双星号 ** 前缀时，表示将一个字典类型的对象拆分成独立的关键字参数。

因此，如果在函数定义中使用 *args，表示函数将接收任意数量的位置参数，这些参数将被收集到一个元组中；如果在函数定义中使用 **kwargs，则表示函数将接收任意数量的关键字参数，这些参数将被收集到一个字典中。如果在函数定义中同时使用 *args 和 **kwargs，则表示函数将接收任意数量的位置参数和关键字参数。

如果在函数定义中在参数前加一个单星号 *，表示将所有的位置参数收集到一个元组中。如果在函数定义中在参数前加两个星号 **，表示将所有的关键字参数收集到一个字典中。如果同时使用 * 和 **，则表示将位置参数收集到一个元组中，关键字参数收集到一个字典中。

python的@property

在 Python 中，@property 装饰器用于将一个方法转化为只读属性，让类的调用者可以像访问属性一样调用该方法，而无需显式地调用方法名。通常情况下，如果需要获取一个属性的值，则需要编写一个 getter 方法。但是，使用 @property 装饰器后，该方法可以像类的其他属性一样调用，从而简化代码。

下面是一个使用 @property 装饰器的示例：

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name

在上述示例中，@property 装饰器将 name 方法转化为只读属性。这意味着，如果要获取 Person 实例的 name 属性，只需使用实例对象的 name 属性访问即可，如下所示：

person = Person('Alice')
print(person.name)

这将输出 Alice，即 person 实例的 name 属性的值。注意，这里不需要显式调用 name() 方法来获取值。

需要注意的是，@property 装饰器只能用于只读属性，如果需要设置属性的值，则需要使用类似于 name.setter 的装饰器来定义一个 setter 方法。

循环删除文件

def del_file(path):
    """删除目录下的文件"""
    list_path = os.listdir(path)
    for i in list_path:
        c_path = os.path.join(path, i)
        if os.path.isdir(c_path):
            del_file(c_path)
        else:
            os.remove(c_path)

pytest的钩子函数

官网：https://docs.pytest.org/en/6.2.x/_modules/_pytest/hookspec.html#pytest_terminal_summary

pytest_terminal_summary

def pytest_terminal_summary(terminalreporter):
    """
    收集测试结果
    """

    _PASSED = len([i for i in terminalreporter.stats.get('passed', []) if i.when != 'teardown'])
    _ERROR = len([i for i in terminalreporter.stats.get('error', []) if i.when != 'teardown'])
    _FAILED = len([i for i in terminalreporter.stats.get('failed', []) if i.when != 'teardown'])
    _SKIPPED = len([i for i in terminalreporter.stats.get('skipped', []) if i.when != 'teardown'])
    _TOTAL = terminalreporter._numcollected
    _TIMES = time.time() - terminalreporter._sessionstarttime
    INFO.logger.error(f"用例总数: {_TOTAL}")
    INFO.logger.error(f"异常用例数: {_ERROR}")
    ERROR.logger.error(f"失败用例数: {_FAILED}")
    WARNING.logger.warning(f"跳过用例数: {_SKIPPED}")
    INFO.logger.info("用例执行时长: %.2f" % _TIMES + " s")

    try:
        _RATE = _PASSED / _TOTAL * 100
        INFO.logger.info("用例成功率: %.2f" % _RATE + " %")
    except ZeroDivisionError:
        INFO.logger.info("用例成功率: 0.00 %")

这会在用例执行完毕之后显示在控制台的

在这里插入图片描述

pytest_configure

钩子函数源码都在\Lib\site-packages\_pytest\hookspec.py文件夹中

这个相当于是pytest.ini中设置pytest的执行规则，主要是为了解决自定义标记 warnings信息。

在pytest.ini中设置和在conftest.py文件中用config.addinivalue_line设置mark标记是一样的效果。

pytest_collection_modifyitems

总结：改变用例的执行顺序

参考：https://blog.csdn.net/mashang_z111/article/details/127266694

【严格意义上来说，我们在用例设计原则上用例就不要有依赖顺序，这样才能更好的体现出测试用例的意义。（测试用例的执行不需要按照顺序来执行，而是随即执行）】

pytest_collection_modifyitems 是在用例收集完毕之后被调用，可以用来调整测试用例执行顺序；
它有三个参数，分别是：
 
session：会话对象；
config：配置对象；
items：用例对象列表；改变items里面用例的顺序就可以改变用例的执行顺序了
 
这三个参数分别有不同的作用，都可以拿来单独使用，修改用例执行顺序主要是使用 items 参数【用例执行之前，收集到的测试用例会以元素对象的方式存放在用例对象列表items中】

staticmethod，classmethod，普通method有什么区别

在 Python 中，类定义中的函数可以被定义为三种不同类型的方法：staticmethod、classmethod 和普通方法（也称为实例方法）。这些方法的区别如下：

普通方法：

普通方法是类中最常见的方法类型。这些方法可以访问并操作类的实例属性和方法，同时还可以使用 self 关键字来引用调用该方法的实例。普通方法通常用于在类实例上执行某些操作。

例如：

MyClass:
    def my_method(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2
        return self.arg1 + self.arg2

obj = MyClass()
result = obj.my_method(1, 2)
print(result)

在这个例子中，my_method 是一个普通方法，它可以访问 MyClass 类的实例属性 arg1 和 arg2，并返回它们的和。

staticmethod：

staticmethod 是一个被装饰器 @staticmethod 修饰的方法。这个装饰器使方法变为静态方法，即该方法既不需要访问类的实例属性和方法，也不需要访问类的类属性和方法，因此不需要传递 self 或 cls 参数。静态方法通常用于实现与类相关的辅助函数。

例如：

MyClass:
    @staticmethod
    def my_static_method(arg1, arg2):
        return arg1 + arg2

result = MyClass.my_static_method(1, 2)
print(result)

在这个例子中，my_static_method 是一个静态方法，它不需要访问类的实例属性和方法，也不需要访问类的类属性和方法，因此不需要传递 self 或 cls 参数。

classmethod：

classmethod 是一个被装饰器 @classmethod 修饰的方法。这个装饰器使方法变为类方法，即该方法需要访问类的类属性和方法，因此需要传递 cls 参数。类方法通常用于实现与类相关的工厂方法。

例如：

MyClass:
    count = 0

    @classmethod
    def from_count(cls):
        obj = cls()
        obj.count = cls.count
        cls.count += 1
        return obj

obj1 = MyClass.from_count()
obj2 = MyClass.from_count()
print(obj1.count, obj2.count)

在这个例子中，from_count 是一个类方法，它需要访问类的类属性 count，因此需要传递 cls 参数。这个方法用于创建 MyClass 类的实例，并将其 count 属性设置为类的类属性 count 的值。这个方法在每次调用时都会递增 count 属性的值，以便为每个新实例创建一个唯一的标识符。

关于缓存

我的问题：

我将一个文件的内容直接读取到python的缓存中，从而避免频繁的IO操作，我想知道python可以有多大的缓存，保证我读取的文件数据不丢失呢

Python 语言没有直接限制缓存大小的参数，因此，理论上讲，Python 缓存的大小可以无限制增加，但实际上，这取决于你的计算机的硬件和操作系统的限制。

一般来说，Python 在内存中创建的对象都会占用一定的空间，而 Python 的内存使用是受限于计算机的物理内存大小的。因此，当你读取大型文件时，缓存大小应该小于计算机的可用内存大小，以避免内存不足的情况。

另外，还需要注意的是，将整个文件读入内存中可能会导致 Python 解释器崩溃或程序崩溃，尤其是对于非常大的文件。因此，如果你需要处理大型文件，最好使用逐行读取或者分块读取的方式，而不是将整个文件读入内存中。这样可以有效减少内存的占用，并避免出现程序崩溃的情况。

关于安全读取yaml数据

示列代码:

res = yaml.load(data, Loader=yaml.FullLoader)

这段代码是将读取到的 YAML 格式数据

data解析为 Python 对象。

yaml.load()的作用是将读取到的 YAML 字符串解析为 Python 对象，这里使用的是 yaml.FullLoader。

yaml.FullLoader是 yaml 库中一个安全的 Loader，它可以反序列化任何 Python 对象，并且不会执行任何代码。

这里的 res 变量将会保存 Python 对象。

需要注意的是，这个函数在较新版本的 PyYAML 库中已经不推荐使用了，因为会存在安全问题。

新版本的 PyYAML 库建议使用 **yaml.safe_load()**函数来代替 yaml.load()函数，以避免 Python 序列化攻击等安全问题。

yaml.safe_load()函数仅仅序列化基本 Python 对象类型，不能反序列化任何带有Python对象类型的数据。

同时，Python 3.10 后，yaml.FullLoader 将被标记为危险的，建议改用 yaml.SafeLoader 来代替。

枚举类型enum

参考文章：https://blog.csdn.net/yuxuan89814/article/details/128592704

1、enum模块

python的枚举类型是继承enum模块的Enum类，定义自己的枚举类，枚举元素相当于类变量

from enum import Enum
class colorEnum(Enum):
    red = 1
    yellow = 2
    blue = 3

枚举类型是name=value的形式，name是不能重复，value可以重复，但是重复的值的别名是第一个的

print(colorEnum.red) #1colorEnum.red
print(colorEnum.gray) #1colorEnum.red
print(colorEnum.red.value) #11

如果要枚举类中的name不相同，则需要引入unique

from enum import Enum, unique
@unique
class colorEnum(Enum):
    red = 1
    yellow = 2
    blue = 3
    gray=1
print(colorEnum.red)
# ValueError: duplicate values found in <enum 'colorEnum'>: gray -> red

2、枚举类型的使用

from enum import Enum
class colorEnum(Enum):
    red = 1
    yellow = 2
    blue = 3
  
print(colorEnum.red)
print(type(colorEnum.red))
print(colorEnum.red.value)
print(type(colorEnum.red.value))

########### 结果
colorEnum.red
<enum 'colorEnum'>
1
<class 'int'>

其他获枚举取值的方式：

枚举变量是name=value的形式:

可以使用value取值value或者name

可以使用name变量去取值value或者name

print(colorEnum(1))
print(colorEnum(1).value)
print(colorEnum["red"])
print(colorEnum["red"].value)

#### 结果
colorEnum.red
1
colorEnum.red
1

获取所有的names和values

使用魔术方法__members__获取values和names,结果是dict数组

print(colorEnum.__members__.values())
print(colorEnum.__members__.keys())

########## 
dict_values([<colorEnum.red: 1>, <colorEnum.yellow: 2>, <colorEnum.blue: 3>])
dict_keys(['red', 'yellow', 'blue'])

实用性举例：

判断变量是否在我们枚举类中，在的话打印出值：

colors=["red","blue","pink"]
for color in colors:
    if color in colorEnum.__members__.keys():
        print(colorEnum[color].value)
        
########## 
1
3

枚举值value：name的映射函数：`_value2member_map_`

from enum import Enum
class colorEnum(Enum):
    red = 1
    yellow = 2
    blue = 3

print(colorEnum._value2member_map_)
###
{1: <colorEnum.red: 1>, 2: <colorEnum.yellow: 2>, 3: <colorEnum.blue: 3>}

使用举例：

color_nums=[1,2,4]
for color_num in color_nums:
    if color_num in colorEnum._value2member_map_:
        print(colorEnum(color_num).name)
        
######
red
yellow

class colorEnum(Enum):
    red = 1
    yellow = 2
    blue = 3
    gray = 1


for color_num in colorEnum._value2member_map_.keys():
    print(color_num)

print(colorEnum._value2member_map_.keys())
print(type(colorEnum._value2member_map_.keys()))

###########
1
2
3
dict_keys([1, 2, 3])
<class 'dict_keys'>

python中re.sub函数

参考文章：https://blog.csdn.net/jackandsnow/article/details/103885422

re是正则的表达式，sub是substitute表示替换

re.sub是相对复杂点的替换

re.sub(pattern, repl, string, count=0, flags=0)

re.sub的参数：5个参数

参数1：pattern

表示正则中的模式字符串。

参数2：repl

就是replacement，表示被替换的字符串，可以是字符串也可以是函数。

参数3：string

表示要被处理和替换的原始字符串

参数4：count

可选参数，表示是要替换的最大次数，而且必须是非负整数，该参数默认为0，即所有的匹配都会被替换；

参数5：flags

可选参数，表示编译时用的匹配模式（如忽略大小写、多行模式等），数字形式，默认为0。

例子：

只替换前两个

import re
a = '44444'
b = re.sub('4', '2', a, 2)
print(b) # 22444

匹配多个连续汉字

import re
a = '   (rr 我)#1  (d 只是)#1  (p 以)#1  (vi 笑) (v 作答)#1#2#3 (。 。)'
a = re.sub(u"[\u4e00-\u9fa5]+", '*', a) # 匹配多个连续汉字，替换为*
print(a) 
## 输出
   (rr *)#1  (d *)#1  (p *)#1  (vi *) (v *)#1#2#3 (。 。)

匹配除了汉字之外的其他符号

# 正则表达式  u"[\u4e00-\u9fa]"  表示所有的汉字  [^...] 表示除了...之外
a = '“设置文件名，怎么样？”'
a = re.sub(u"[\u4e00-\u9fa]", '', a)
print(a)   # 设置文件名怎么样