python + selenium ：web自动化测试
python + appium：移动端自动化测试
python + requests：接口测试

IDE（PyCharm）：集成开发环境
Ctrl + Alt + L：格式化代码

数据类型转换，不会改变原来数据的类型，会生成一个新的数据类型。
将其他类型转换为整型
1）可以将 类型转换为整型
2）将 转换为整型

将其他类型转换为 浮点型
1）可以将类型转换为 浮点型
2）将转换为 浮点型

将其他类型转换为 字符串类型
任何类型都可以使用将其转换为字符串

指定显示小数点后几位 ，n需要换成具体的整数数字，即保留小数的位数
整数一共占几位 ，n需要换成具体的整数数字
需要显示%（90%），需要使用两个

顺序
分支
循环：让指定代码按照指定次数重复执行

死循环和无限循环

死循环：代码一直不停的运行下去，一般是由写代码的人不小心造成的bug
无限循环：写代码的人故意让代码无限制的去执行，代码一直不停的运行下去。
无限循环使用场景：在书写循环时，不确定循环要执行多少次。
无限循环的使用：一般会在循环中添加一个判断，当if条件成立，使用关键字来终止循环

：结束循环（用的最多）
：结束本次循环，继续下次循环
： 生成之间的整数数字，不包含b
：不包含end

产生随机数

for循环基本格式

转义字符：

字符串前边加上原生字符串，字符串中的不会作为转义字符，文件操作会用

切片：包左不包右

步长为负数，反转（逆置）字符串

字符串的查找方法 find

若找到，返回sub_str第一次出现的下标
若没有找到，返回-1

字符串的替换方法 replace

返回：替换之后的完整的字符串，原来的字符串没有发生改变

: 替换的次数，一般不写，默认是全部替换

字符串的拆分 split

-：字符串按照什么进行拆分，默认是空白字符（空格，换行 ，tab键 ）
-：分割次数，一般不写，全部分割
返回：将一个字符串拆分为多个，存到列表中
注意：如果sep不写，想要指定分割次数，则需要按照如下方式使用：

字符串的连接 join

作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
列表中的数据使用逗号隔开
注意：列表中的数据必须是字符串

，可以存储任意类型的数据，列表中的数据之间使用逗号隔开
定义一个空列表

列表支持下标、切片和长度
列表的切片得到的是列表

查找数据下标 index

找到返回第一次出现的下标，没有找到代码直接报错

查找 - 判断是否存在 in

查找 - 统计出现的次数 count

添加数据

• 尾部添加： ，返回None（空），一般不再使用 变量 来保存返回的内容；想要查看添加后的列表，需要打印列表
• 指定下标位置添加：，如果指定下标位置本来有数据，原数据会后移，返回None（空）
• 列表合并：，将列表2中的所有数据逐个添加到列表1的尾部，返回None

列表推导式：快速生成列表

修改操作

修改列表中指定下标位置的数据

如果指定的下标不存在，代码会报错
注意：字符串中字符不能使用下标修改

删除操作

在列表中删除中间的数据，后面的数据会向前移动

• 根据下标删除：

下标不写，默认删除最后一个数据
书写存在的下标，删除对应位置的数据
返回值：返回删除的数据

• 根据数据值删除：

返回值：None
注意：如果要删除的数据不存在，会报错
如果列表中有多个该数据值，只能删除第一个，若想全部删除，则使用循环

• 清空数据（一般不用）：

列表的反转（倒置）

1、：使用切片的方法会得到一个新列表，原列表没有发生改变
2、：直接修改原列表，返回None

列表的复制

将列表中的数据复制一份，给到一个新的列表
使用场景：有一个列表，需要修改操作列表中的数据，修改之后，需要和原数据进行对比，即原数据不能改

1、使用切片：
2、

列表的排序

一般都是对数字进行排序

列表的嵌套

列表中的内容还是列表
使用下标来确定获取的是什么类型的数据，然后确定可以继续进行什么操作

列表去重

方式1：遍历原列表中的数据判断在新列表中是否存在，如果存在不管，如果不存在，放入新列表中

方式2：使用集合（）集合中不能有重复的数据，如果有重复的数据会自动去重
①使用类型转换 将列表转化为集合类型
②再使用类型转换 将集合转换为列表

缺点：不能保证数据在原列表中出现的顺序（一般不考虑这件事）

元组：，元组的特点和列表非常相似
1）元组中可以存放任意类型的数据
2）元组中可以存放任意多个数据
区别：
1）元组中的数据内容不能改变，列表中的可以改变
2）元组使用，列表使用[]
应用：在函数的传参或者返回值中使用，保证数据不能被修改
定义：
1）使用类实例化：

2）直接使用()定义

注意：定义只有一个数据的元组时，数据后边必须要有一个逗号

由于元组中的数据不能修改，所以只有查看的方法
1、在元组中可以使用获取数据
2、存在方法
3、存在方法
4、可以使用操作
以上方法的使用，和列表中一样

字典 ，由组成（键表示数据的名字，值就是具体的数据）
一组键值对是一个数据，多个键值对之间使用逗号隔开

一个字典中的键是唯一的，不能重复，值可以是任意数据
字典中的键一般都是字符串，可以是数字，不能是列表
dict()不能转列表、元组、字符串

定义

1、使用类实例化

2、直接使用{}定义

增加和修改操作

若键已经存在，就是修改数据；若键不存在，就是添加数据

删除

删除指定键值对：，
清空：

查询-根据键获取对应的值

1、使用
如果键存在，返回键对应的数据值；
如果键不存在，会报错
2、使用
完整写法：
数据值一般不写，默认是None
如果键存在，返回键对应的数据值；
如果键不存在，返回括号中书写的数据值None

字典的遍历

• 对 字典的键 进行遍历

• 对 字典的值 进行遍历

• 对 字典的键值对 进行遍历

• 字符串、列表、元组 都支持加法运算
• 字符串、列表、元组 都支持乘一个数字
• 在容器中都可以使用
• 关键字在容器中都可以使用，在字典中判断的是字典的键是否存在

定义：

调用：

书写位置：在函数名的下方使用，三对双引号
作用：告诉别人函数是如何使用的、有什么作用
查看：调用时放到函数名上 使用 Ctrl+q（Windows），Ctrl+j（Mac）
Ctrl（cmd） B转到函数声明中查看（按Ctrl（cmd）鼠标左键点击）

在一个函数定义中调用另一个函数

• 函数定义不会执行函数体中的代码
• 函数调用会执行函数体中的代码
• 函数体中代码执行结束会回到函数被调用的地方继续向下执行

形参 parameter：函数定义时的参数，起到占位作用，没有具体数据值
实参 argument：函数调用时，括号中的数据会传递给形参，是具体数据值
在定义函数时如果有形参，那么在调用的时候必须要传递实参值，且个数要对应

函数传参的方式

位置传参：在函数调用时，按照形参顺序，将实参值传递给形参
关键字传参：在函数调用时，指定将数据值给哪个形参，关键字必须是 函数的形参名
混合使用：关键字传参必须写在位置传参后面，不要给一个形参传递多个数据值

缺省参数（默认参数）

定义方式：在函数定义时，给形参一个默认数据值，这个形参就变为缺省参数，注意：缺省参数的书写要放在普通参数后边
特点：缺省参数在函数调用时，可以传递实参值，也可以不传实参。如果传参使用的就是传递的实参值，若不传参，使用默认值

多值参数（可变参数、不定长参数）

在书写函数时，若不确定参数的具体个数时，可以使用不定长参数
不定长位置参数（不定长元组参数）

• 书写：在普通参数前加一个*，这个参数就变为不定长位置参数
• 特点：这个形参可以接受任意多个位置传参的数据
• 数据类型：形参的类型是 元组
• 注意：不定长位置参数要写在普通参数后面
• 一般写法：不定长位置参数的名字为，即

不定长关键字参数（不定长字典参数）

• 书写：在普通参数前加两个*，这个参数就变为不定长关键字参数
• 特点：这个形参可以接受任意多个关键字传参的数据
• 数据类型：形参的类型是 字典
• 注意：不定长关键字参数要写在所有参数后面
• 一般写法：不定长关键字参数的名字为，即

完整的参数顺序

函数中得到的数据在后续代码中还要使用，这个时候就应该将这个数据作为返回值返回，以供后续使用
关键字：（只能在函数中使用）
作用：
① 将数据值作为返回值返回
② 函数代码执行遇到，会结束函数的执行

返回多个数据值

将多个数据值组成容器进行返回，一般是元组

在定义变量时，变量 = 数据值，python解释器会在内存中开辟两块空间；
变量和数据都有自己的空间；
本质是将数据的地址保存到变量对应的内存中；
变量中存储数据地址的行为就是引用（变量引用了数据的地址），存储的地址为引用地址；
可使用来获取变量中的引用地址（数据的地址），如果两个变量的id()获取的引用地址一样，即两个变量引用了同一个数据；
只有 赋值运算符= 可以改变变量的引用 ；
可变类型做参数，在函数内部，如果不使用 = 直接修改形参的引用，对形参进行的数据修改会同步到实参中
python中数据的传递，都是传递的引用
列表的操作，本质是操作

数据类型：
可变不可变指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型
可变类型：
不可变类型：

交换两个变量的值

组包和拆包

组包（pack）：将多个数据值使用逗号连接，最终组成元组
拆包（unpack）：将容器中的数据值使用多个变量分别保存的过程，注意：变量个数和容器中数据的个数要保持一致，对字典拆包得到字典的键

局部变量

定义位置：在函数内部定义的变量
特点：

• 只能在当前函数内部使用，不能在其他函数和函数外部使用
• 在不同函数中，可以定义名字相同的局部变量，两者之间无影响
• 生存周期（生命周期，作用范围）：在函数被调用时，局部变量被创建，函数调用结束，局部变量的值被销毁，不能使用。因此函数中的局部变量的值如果想在函数外部使用，需要使用return将这个值进行返回
• 形参属于局部变量

全局变量

定义位置：在函数外部定义的变量
特点：

• 可以在任何函数中读取全局变量的值
• 如果在函数中存在和全局变量相同名字的局部变量，在函数中使用的是局部变量的值（就近）
• 在函数内部想要修改全局变量的引用，需要添加关键字，对变量进行声明为全局变量
• 生命周期：代码执行时被创建，代码执行结束被销毁

• 用关键字能创建小型匿名函数，只能书写一行代码
• 这种函数省略了用def声明函数的标准步骤
• 能接收任何数量的参数，返回值不需要return，但只能返回一个表达式的值
• 一般不需要调用，作为函数的参数使用

1、在定义时，将匿名函数的引用保存到一个变量中

2、使用变量进行调用

匿名函数作为函数的参数-列表中的字典排序

列表的排序，默认是对列表中的数据进行比大小，可以对数字类型和字符串进行比大小
对字典来说，需要使用中的参数，来指定字典比大小的方法
：需要传递一个函数，一般是匿名函数，字典的排序，要指定根据字典的什么键进行排序，只需要使用匿名函数返回字典的这个键对应的值即可

匿名函数中的参数是列表中的数据，在sort函数内部，会调用key这个函数（将列表中每个数据作为实参传递给形参），从列表中获取函数的返回值，对返回值比大小

字符串比大小

字符比大小：字符对应的ASCII 码值
A < Z < z < a
获取字符对应的ASCII 码值
获取对应的字符
字符串比大小：对应下标位置字符的大小，直到比出大小，若全部比完还没有比出大小，就是相等

面向过程：关注的是 具体步骤的实现，所有功能都自己书写；定义一个函数，最终按照顺序调用函数
面向对象：关注的是 结果，对象能做这件事；找一个对象，让其去做

三大特征

• 封装：根据职责将 属性和方法 封装到一个抽象的 类 中
• 继承：实现代码的重用，相同的代码不需要重复编写
• 多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码灵活性

类：抽象的概念，对多个特征（属性）和行为（方法）相同或相似事物的统称，泛指（指代多个），不能直接使用。负责创建对象
对象：具体存在的一个事物，特指（指代一个）

类

组成：

• 类名：大驼峰命名法-每个单词的首字母大写
• 属性：事物的特征，即有什么，一般是名词
• 方法：事物的行为，即做什么，一般是动词

类的抽象（设计）：找到类的类名、属性和方法
面向对象代码步骤：

• 定义类，在定义类之前先设计类
• 创建对象，使用第一步定义的类创建对象
• 通过对象调用方法

面向对象基本代码的书写

1、定义类
关键字：
方法的本质是在类中定义的函数，只不过第一个参数是

2、创建对象

一个类可以创建多个对象，只要出现 就是创建一个对象，每个对象的地址不一样

3、调用方法

简单案例

self的说明

1、从函数语法上讲，是形参，可以是任意的变量名
2、是普通的形参，但是在调用的时候没有传递实参值，原因是python解释器在执行代码时，自动将调用这个方法的对象 传递给了，即
3、self是函数中的局部变量，直接创建的对象是全局变量

对象的属性操作

• 添加属性

类内部添加：在内部方法中，self是对象，在类中添加属性一般写在中

类外部添加：一般不使用

• 获取属性

类内部：
类外部： 一般很少使用

魔法方法

python中有一类方法，以两个下划线开头、两个下划线结尾，并且在满足某个条件的情况下，会自动调用。
–什么情况下自动调用？
–有什么用，用在哪？
–书写的注意事项

方法⭐⭐

• 创建对象之后会自动调用
• 作用：用于给对象添加属性，初始化方法/构造方法；某些代码，在每次创建对象之后都要执行，就可以将这些代码写在方法
• 如果在方法中，存在除了之外的参数，在创建对象时必须传参

方法⭐

• 使用 打印对象时 会自动调用
• 一般书写对象的 属性信息，即打印对象时想要查看什么信息，在这个方法中进行定义
• 若类中没有定义方法，print(对象) ，默认输出对象的引用地址
• 必须返回 一个字符串

方法 [了解]
对象被删除销毁时，自动调用
调用场景：

• 程序代码运行结束，所有对象都被销毁
• 直接使用 （如果对象有多个名字，即多个对象引用一个对象，需要把所有的对象都删除才行）

案例1

案例2

案例3

案例4

设计类

类名：房子类 House
属性：户型 name，面积 total_area，家具名称列表 item_list = []，剩余面积 free_area = total_area
方法：，，
添加家具方法

类名：家具类 HouseItem
属性：名字 name，占地面积 area
方法：，

案例5

在python中定义的属性和方法，可以添加访问控制权限
访问控制权限分为两种：公有权限和私有权限
公有权限：

• 直接书写的属性和方法
• 共有的属性和方法，可以在任意地方访问和使用

私有权限：

• 在类内部，属性名或方法名，前边加两个 下划线 ，这个属性或方法就变为私有的
• 只能在当前类内部使用
• 本质：当python解释器执行代码时，发现属性名或方法名前有两个 下划线，会将这个名字重命名，会在这个名字前边加上 _类名 前缀，即

什么时候定义私有

• 某个属性或方法，不想在类外部被访问和使用
• 测试中，一般不怎么使用，直接公有即可
• 开发中，会根据需求文档，确定什么作为私有

若想在类外部操作私有属性，方法是：在类内部定义公有的方法，通过这个方法去操作

子类可以直接使用父类的公有属性和方法
语法：

A类 称为父类（基类）
B类 称为子类（派生类）
单继承：一个类只继承一个父类

在子类中定义了和父类中名字相同的方法。
原因：父类中的方法，不能满足子类对象的需求
特点：调用子类自己的方法，不再调用父类中的方法
方式：

• 覆盖：父类中功能完全抛弃–直接在子类中 定义和父类中名字相同的方法

• 扩展：父类中功能还调用，只是添加一些新的功能（使用较多）----直接在子类中 定义和父类中名字相同的方法；在合适的地方调用 父类中的方法 ；书写添加新的功能

不同的 子类对象 调用相同的 父类方法，产生不同的执行结果
可以增加代码的灵活度
哪个对象调用方法，就去自己的类中去查找这个方法，找不到去父类中找

python中一切皆对象，即使用定义的类 也是一个对象

对象的划分

实例对象（实例）

通过 创建的对象，称为实例对象，简称实例
创建对象的过程 叫做 类的实例化
我们平时所说的对象就是指 实例对象（实例）
每个实例对象都有自己的内存空间，在自己的内存空间中保存自己的属性

创建对象的动作叫做 实例化
对象的属性 叫做 实例属性
对象调用的方法 叫做 实例方法

类对象（类）

类对象 就是 类，或可以认为是
类对象是python解释器在执行代码过程中创建的
作用：①使用类对象创建实例
②有自己的内存空间，可以保存一些属性值信息（类属性）
在一个代码中，一个类只有一份内存空间

属性的划分

实例属性

概念：实例对象 具有的属性
定义：在方法中，使用
使用：在方法中使用 来获取（调用）
内存：在每个实例中都存在一份
使用场景：

• 基本上99%都是实例属性，即通过去定义
• 找多个对象来判断这个值是不是都是一样的，如果是一样的，同时变化，则一般定义为 类属性，否则定义为 实例属性

类属性

概念：类对象 具有的属性
定义：在类内部，方法外部，直接定义的变量
使用： or
获取：
内存：只有类对象中存在一份

可以使用 获取类属性的值：实例对象属性的查找顺序是先在实例属性中找，找到直接使用；没有找到会去类属性中找，找到了可以使用，没有找到会报错

练习

方法的划分

方法：使用 关键字定义在类中的函数

实例方法（最常用）

定义：在类中直接定义的方法

定义时机（什么时候用）：如果在方法中需要使用实例属性，即需要使用self
调用： 不需要给self传参

类方法（会用）

定义：在方法名字的上方书写 装饰器

定义时机（什么时候用）：前提–方法中不需要使用实例属性(即self）；用到了类属性，可以将这个方法定义为类方法，也可以定义为实例方法
调用：
① 通过类对象调用 不需要给cls传参，python解释器自动传递
② 通过实例对象调用 不需要给cls传参，python解释器自动传递

静态方法（基本不用）

定义：在方法名上方书写 装饰器

定义时机（什么时候用）：前提–方法中不需要使用实例属性(即self）；也不使用类属性，可以将这个方法定义为静态方法
调用：
① 通过类对象调用
② 通过实例对象调用

练习

哈希（）：是一个算法，可以对数据产生一个唯一的值（指纹）
关键字 用来判断两个对象是不是同一对象，即两个对象的引用是否相同

和 的区别？
只判断数据值是否相同
判断引用是否相同

• 计算机的 文件，就是存储在某种 长期存储设备 上的一段 数据
• 长期存储设备：硬盘、U盘、移动硬盘、光盘…
• 作用：将数据长期保存下来，在需要的时候使用
• 存储方式：二进制

可根据 文件中的二进制内容，能否使用记事本软件 将其转换为文字，将文件分为两种：文本文件和二进制文件
文本文件：能够使用记事本软件打开
、、、、、、
二进制文件：不能使用记事本软件打开
、、、、

步骤：

• 1、打开文件
• 2、读或写文件
• 3、关闭文件

打开文件

将文件从磁盘（硬盘）中 读取到内存
语法：

参数：

• ：要打开的文件，类型是字符串，文件的路径可以是相对路径，也可以是绝对路径（从根目录开始），建议使用相对路径（相对于当前代码文件所在的路径，https://blog.csdn.net/weixin_44129933/article/details/ …/）
• ：默认参数（缺省参数），表示打开文件的方式 ：（read）只读打开；（write）只写打开；（append）追加打开，在文件的末尾写入内容
• ：编码方式 – ：将一个汉字转换为2个字节二进制；：将一个汉字转换为3个字节二进制（常用）
• 返回值：返回 文件对象

读或写文件

写文件

向文件中写入指定内容
前提：文件的打开方式是 或者

返回值：写入文件的字符数，一般不关注
注意 方式打开文件：

• 文件不存在，会直接创建文件
• 文件存在，会覆盖原文件（将原文件内容清空）

读文件

将文件中的内容读取出来
前提：文件的打开方式是
如果文件不存在，代码会报错

返回值：读取到的文件内容，类型为字符串

关闭文件

将文件占用的资源进行清理，同时会保存文件，文件关闭之后，这个文件对象就不能再使用了

使用with open打开文件

好处：不用自己书写关闭文件的代码，会自动进行关闭

方式打开文件：
文件不存在会创建文件；
文件存在，会在文件的末尾写入内容

按行读取文件内容

一次读取一行内容

和 读到文件末尾，返回一个空字符串，即长度为0

json文件的处理

文件也是一个文本文件，就可以直接使用和方法操作文件，只是使用这两种方法不方便，所以对文件有自己独特的读取和写入方法
常用在做测试时，将测试数据定义为文件格式，使用代码读取文件，即读取测试文件，进行传参（参数化）

json文件介绍

JSON的全称是 JavaScript Object Notation，是JavaScript对象表示法，它是一种基于文本，独立于语言（不是某个语言特有的，每种编程语言都可以使用）的轻量级（相同数据 相较于其他格式，占用大小 小）数据交换格式（后端程序员给前端的数据：html xml json）。
特点：

• 是纯文本
• 具有良好的自我描述性，便于阅读和编写
• 具有清晰的层级结构
• 有效提升网络传输效率

json文件的语法

后缀
主要数据类型：对象（ 类似python种的字典）和数组（，类似python种的列表），对象和数组可以互相嵌套
一个文件是一个 对象或数组，即文件的最外层要么是一个 对象{}，要么是一个 数组[]
中的对象由键值对组成，每个数据之间使用 逗号隔开，但是最后一个数据后边不要写逗号
中的字符串必须使用双引号
中的其他数据类型：

• 数字类型 ------>int float
• 字符串 string ------>str
• 布尔类型 ------>True，False
• 空类型 ------>None

json文件的书写

读取json文件 ⭐⭐

1、导包
2、读（默认） 打开文件
3、读文件
返回：字典（文件中是对象）或列表（文件中是数组）

json的写入

不能直接将python的列表和字典作为参数传递
步骤：

• 1、导包
• 2、写 方式打开文件
• 3、写入

基本语法

捕获多个指定类型的异常

好处：可以针对不同的异常错误，进行单独的代码处理

异常捕获的完整版本

完整版本中的内容，不是说每一次都要全部书写，根据自己的需要，选择其中的进行使用
是常见异常类的父类，这里书写可以捕获常见的所有异常，，这个变量是一个异常类的对象，可以打印异常信息

常用

异常传递：在函数嵌套调用过程中，被调用的函数发生了异常，如果没有捕获，会将这个异常向外层传递；如果传到最外层还没有捕获，会报错

语法：

对于导入的模块和工具可以使用 关键字给其起别名
注意：如果起别名，原来的名字就不能用了，只能使用别名

在导入模块时，会先在当前目录中找模块，如果找到直接使用；如果没找到会去系统的目录中找，若找到直接使用，没有找到会报错
注意：定义代码文件时，文件名不能和导入的模块名相同

test.py

在python中，包是一个目录，存在一个文件中，可以是空的
将功能相近或相似的代码放在一起
使用时，无需刻意区分是包还是模块，使用方式相同
模块（单个代码文件）
包（目录）
使用：
1、
2、 快捷导入

框架（framework）：为解决一类事情的功能集合

UnitTest框架：是python自带的一个单元测试框架，用它来做单元测试。
自带的框架（官方）：不需要额外安装，只要安装了python就可以使用 、、、
第三方框架：想要使用 需先安装 、、
单元测试框架：主要用来做单元测试，一般单元测试由开发做
作用：自动化脚本（用例代码）执行框架，即 使用UnitTest框架来管理 运行 多个测试用例

• ① 能够组织多个用例去执行
• ② 提供丰富的断言方法（让程序代码代替人工自动的判断预期结果和实际结果是否相符）
• ③ 能够生成测试报告

• 1、（测试用例）：最核心模块 是UnitTest框架的组成部分，不是手工和自动化中所说的用例（Test Case）。主要作用：每个（测试用例）都是一个代码文件，在这个代码文件中书写真正的用例代码
• 2、（测试套件）：用来管理 组装 多个 （测试用例）
• 3、（测试执行）：执行 （测试套件）
• 4、（测试加载）：对 （测试套件）功能的补充，管理 组装 多个 （测试用例）
• 5、（测试夹具）：书写在 （测试用例）代码中，是一种代码结构，在每个方法执行前后都会执行的内容。每个用例中重复的代码就可以写于此，只写一遍，但每次用例方法的执行，都会执行 中的代码

• 1、导包
• 2、实例化（创建对象）套件对象
• 3、使用 套件对象 添加 用例方法
• 4、实例化 运行对象
• 5、使用运行对象 去执行 套件对象

套件和执行

testlogin.py

作用和一样，是对功能的补充，用来组装 管理 测试用例
使用步骤：

• 1、导包
• 2、实例化 测试加载对象 并添加用例，得到的是 对象
• 3、实例化 运行对象
• 4、运行对象执行套件对象

在一个项目中 （测试用例）的代码，一般放在一个单独的目录中

方法级别[掌握]

在每个测试方法（用例代码）执行前后都会自动调用的结构

类级别[掌握]

在每个测试类中所有方法执行前后 都会自动调用的结构（在整个类中 执行之前执行之后 各一次）
类级别的方法 是一个类方法

模块级别[了解]

模块：代码文件
在每个代码文件执行前后执行的代码结构
需要写在类的外边 直接定义函数即可

方法级别和类级别 前后的方法，不需要同时出现，根据用例代码的需要自行选择使用

案例

• 1、打开浏览器（整个测试过程中只打开一次浏览器） 类级别
• 2、输入网址（每个测试方法都需要一次）方法级别
• 3、输入用户名密码验证码点击登录（不同测试数据） 测试方法
• 4、关闭当前页面（每个测试方法都需要一次）方法级别
• 5、关闭浏览器（整个测试过程关闭一次浏览器）类级别

让程序代替人工自动判断 预期结果和实际结果是否相符
断言结果：

• 用例通过
• 代码抛出异常，用例不通过

方法

判断预期结果和实际结果是否相等

如果相等，用例通过
如果不相等，用例不通过，抛出异常

方法

判断预期结果是否包含在实际结果中

包含，用例通过
不包含，用例不通过，抛出异常

在测试方法中，使用 变量 来代替具体的测试数据，然后使用传参的方法将测试数据传递给方法的变量
优点：相似的代码无需多次书写
工作中场景：
1、测试数据一般放在 文件中
2、使用代码读取 文件，提取我们想要的数据 —> or 格式

安装插件

unittest 框架本身不支持参数化，想要使用参数化，需要安装插件来完成
联网安装

验证

新建一个python代码文件，导包验证

参数化代码

步骤：

• 1、导包
• 2、定义测试类
• 3、书写测试方法（用到的测试数据使用变量代替）
• 4、组织测试数据并传参

data.json

参数化代码

对于一些未完成或不满足测试条件的测试函数和测试类，不想执行，可以使用跳过
使用方法：装饰器完成
代码书写在 文件中
① 直接将测试函数标记成跳过

② 根据条件判断测试函数是否跳过，判断条件成立则跳过

自带的测试报告

只有单独运行的代码，才会生成测试报告

生成第三方的测试报告

是一个第三方的类库，用来执行测试用例并生成HTML格式的测试报告
步骤：

• 1、获取第三方的测试运行类模块，将其放在代码的目录下
• 2、导包
• 3、使用 套件对象 or 加载对象 去添加用例方法
• 4、实例化 第三方运行对象 并运行套件对象

英文报告

流程：
1、组织用例文件（里），书写参数化、断言、Fixture、跳过，如果单个测试文件直接运行，得到测试报告，如果有多个测试文件，需要组装运行生成测试报告
2、使用 套件对象组装 or 加载对象 组装
3、运行对象 运行：运行对象=第三方运行类(文件对象(打开文件需要使用方式)）；运行对象.run(套件对象)

中文测试报告