测试基础知识

测试学习部分

技能：

1.功能测试+接口测试

2.功能测试+性能测试

3.功能测试+web自动化

就业方向：

1.功能+接口

2.自动化+接口

3.接口+性能

按阶段划分：

1.单元测试：针对程序源代码进行测试（开发）

2.集成测试：又称接口测试，主要针对模块与模块或系统与系统之间的接口进行验证

3.系统测试：针对软件全面进行验证（功能、兼容、文档）

4.验收测试：使用内测、公测来实现

内测：公司内部进行测试。

公测：让玩家来进行测试。

按代码可见度划分：

1.黑盒测试：自动化测试，功能测试。（完全看不见源代码）

2.灰盒测试：又称接口测试（看不见部分代码）

3.白盒测试：又称单元测试（针对程序源代码进行测试）

扩展总结：

1.系统测试和黑盒测试重点核心是<功能测试>

2.集成测试和灰盒测试又称<接口测试>

3.单元测试和白盒测试是对<代码>进行测试

4.自动化测试归属<功能测试>

5.性能测试、安全测试归属<专项测试>

扩展-测试策略：

冒烟测试：大规模执行测试之前，针对程序主功能进行验证，保证程序具备可测性。

面试题：提测标准是什么？--冒烟测试通过！测试之前要怎么做？--冒烟测试

 模型：

1.质量模型

2.测试模型

学到了什么？----针对任何软件或硬件，测试要覆盖的方面

1.重点：功能、兼容、性能、易用、安全

w模型

学到什么？--软件开发流程、软件测试在开发流程中的作用

1.开发流程：需求分析、概要设计、详细设计、编码、集成、实施、交付。

2.测试流程：系统测试设计、集成测试设计、单元测试设计、单元测试、集成测试、系统测试、验收测试。 

步骤：

1.需求分析

2.测试用例

3.编写用例

4.执行用例

5.缺陷管理

6.测试报告

需求分析

1.确定各部门对需求理解一致。

2.站在不同角度对需求进行查漏补缺。

测试计划

核心：

1.测什么：测试目标及范围

2.谁来测：人员进度安排

3.怎么测：测试策略、测试工具

测试用例设计 

1.说明：设计执行测试的文档

缺陷管理

说明：提交-验证-关闭

测试报告

说明：测试目标、测试过程、缺陷统计、缺陷分析、测试总结

测试用例：

用例：用户使用的案例

测试用例：执行测试的文档（用户使用的案例）

考虑点：质量模型（功能、性能、兼容、易用、安全）

测试用例的作用：

防止漏测

实施测试的标准

格式（八大要素）：

今天目标：

1.能够针对穷举场景设计测试点

2.能够针对限定边界规则设计测试点

3.能够对多条件依赖关系设计测试点

4.能够使用对于项目业务进行设计用例

一、等价类分析方法：（解决穷举问题）

分类：

有效等价：所有有效数据集合，取一个即可。

无效等价：所有无效数据集合，取一个即可。

步骤：

1.明确需求

2.确定有效和无效等价类

3.提取数据编写用例

用例执行：

提示：预期结果与实际结果不一致，为缺陷。

针对：需要有大量数据测试输入，但是没法穷举测试的地方。

1.输入框

2.下拉列表

3.单选复选框

典型代表：页面级的输入框类测试。 

边界值分析法（只能用数值）：

1.边界范围节点

选取正好等于、刚好大于、刚好小于边界的作为测试数据

上点:边界上的点（正好等于）

离点：距离上点最近的点（刚好大于、刚好小于）

内点：范围内的点（区间范围内的数据）

优化：

边界上的点：开内闭外

开区间：不包含（）

闭区间：包含[]

示例：6<=qq<=10-->开内闭外-->5、11进行测试(7、9）去除。 

2.应用设计步骤

3.案例

4.适用场景

在等价类的基础上针对有边界范围的测试数据输入的地方（重点关注边界）

常见词语描述；大小、尺寸、最大、最小、至多、至少等修饰词语

典型代表：有边界范围的输入框类测试

提示：边界值可以覆盖等价类的长度，但是无法覆盖类型。所以设计用例时，必须两者结合。

三、解决多条件依赖问题

3.判定表法设计用例步骤

1.明确需求

2.画出判定表 1）列出条件桩和动作桩

                      2）填写条件项，对条件进行全组合

                      3）根据条件项的组合确定动作项

                      4）简化、合并相似规则（有相同的动作）

判定表定义及组成部分

定义：是一种以表格形式表达多条件逻辑判断的工具。

组成：

条件桩：列出问题中的所有条件，列出条件的次序无关紧要。

动作桩：列出问题中可能采取的操作，操作的排列顺序没有约束。

条件项：列出条件对应的取值，所有可能情况下的真假值。

动作项：列出条件项的、各种取值情况下应该采取的动作结果。

规则：

判定表中贯穿条件项和动作项的一列就是一条规则

假设有n个条件，每个条件的取值有两个(0,1)，全组合有2的n次方种规则

应用场景：

有多个输入条件，多个输出结果，输入条件之间有组合关系，输入条件和输出结果之间有依赖（制约）关系。

判定表一般适用于条件组合数量较少的情况（比如4个条件以下）

提示：如果碰到项目中多条件组合大于4个相互依赖，可以使用（正交表和因果图来实现）

目标回顾：

1.解决穷举测试点覆盖问题

2.解决边界限制测试点覆盖问题

3.解决多条件组合依赖测试点覆盖问题

4.解决项目业务场景测试点覆盖问题【重点】

场景法：

1.介绍

说明：场景法也可以叫做流程图法，是用流程图描述用户的使用场景，然后通过覆盖流程路径来设计测试用例。

意义：

用户使用角度：用户平时使用的不是单个功能，而是多个功能组合起来进行使用。

测试人员角度：平时测试的都是单个功能点进行测试，容易忽略多个功能的组合测试。

缺陷的判定标准（bug）：

软件未实现需求（规格）说明书中明确要求的功能-少功能

软件出现了需求（规格）说明书中指明不应该出现的错误-功能错误

软件实现的功能超出需求（规格）说明书指明的范围-多功能

软件为实现需求(规格）说明书中虽未明确指明但应该实现的要求-隐形功能错误

软件难以理解，不易使用，运行缓慢，用户体验不好-不易使用

结论：

是软件就有缺陷。

怎么知道是前端Bug还是后端Bug？抓包：前端给后端发送的所有信息都拦截下来。

                                                                  目的：检查请求和响应的数据是否正确。

                                                1.如果是界面或兼容性的错误为前端bug。

                                                2.如果是功能错误区分前端和后端bug，需要抓包查看请求和响应。

作用：方便评审、方便执行。

用例标题：预期结果（测试点）。

面试题：发现bug后怎么办？--确认bug可复现。

缺陷管理工具

工具名称：禅道、jira

对测试而言的作用：

缺陷管理【重点】

用例管理

禅道提交bug

———————————————————————————————————————————

Python学习部分

目标：

1.学习掌握python的基本语法

2.在代码中遇到常见的错误，自己能动手解决问题

Python只是一个编程语言，在工作中需要结合其他的工具使用

Python+selenium web 自动化（功能测试转为代码）

Python+appium 移动端（手机APP）自动化

Python+requests 接口

变量名的起名规范

起名字的规范，标识符的规则

1.必须由字母 数字和下划线组成，并且不能以数字开头

2.不能使用Python中的关键字作为变量名

   关键字：Python自带的已经使用的标识符，具有特殊的作用

3.区分大小写

4.建议性的命名

         驼峰命名法：

                大驼峰：每个单词的首字母大写 MyName

                小驼峰：每一个单词的首字母小写，其余单词的首字母大写 myName

         下划线连接法：每个单词之间使用下划线连接 my_name

                  python中的变量的定义使用的是 下划线连接

        见名知意:

                  name 姓名 age 年龄 height 身高...

数据类型转换：

         

 

 格式化输出

格式化输出占位符号

%d 占位，填充 整型数据 digit

%f  占位，填充 浮点型数据 float

%s 占位，填充 字符串数据 string   

快捷键（小操作）

添加引号括号：可以直接选中要添加引号或者括号的内容，书写即可

撤销：Ctrl Z

删除一行：Ctrl x

复制粘贴一行：Ctrl d

快速 在代码下方，新建一行：shift 回车

F-string(f字符串的格式化方法）

f-string 格式化的方法，想要使用，python版本>=3.6

1.需要在字符串的前边加上f""或者F""

2.占位符号统一变为{}

3.需要填充的变量 写在{}中

  

debug 调试代码

查看代码的执行

break和continue

break 和 continue是 python 中的两个关键字，只能在循环中使用

break：终止循环，即代码执行遇到 break，循环不再执行，立即结束

continue：跳过本次循环。即代码执行遇到 continue ，本次循环剩下的代码不再执行，继续下一次的循环。

容器

容器：也可以称为是数据序列，或者高级数据类型，也是Python中的数据类型

容器中可以存放多个数据。

字符串

字符串是容器，因为字符串可以包含多个字符

定义

定义：使用引号（单引号，双引号，三引号）引起来的内容就是字符串

切片

可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）

语法：

字符串[start:end:step]

start是开始位置的下标，end是结束位置的下标（注意，不能取到这个位置的字符）

step是步长，等差数列的差值，所取的相邻字符下标之间的差值，默认是1，可以不写。

例：[1:5:1]  # 1 2 3 4 

字符串的替换方法 replace

字符串.replace(old_str, new_str, count) # 将字符串中 old_str 替换为 new_str

old_str：被替换的内容

new_str：替换为的内容

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

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

字符串的拆分 split

字符串.split(sep, maxsplit) # 将字符串按照 sep 进行分割（拆分）

-sep,字符串按照什么进行拆分，默认是空白字符（空格，换行\n, tab键\t）

-maxsplit, 分割次数，一般不写，全部分割

-返回：将一个字符串拆分为多个，存到列表中

-注意：如果 sep 不写，想要指定分割次数 则需要按照如下方式使用

字符串.split(maxsplit=n)  # n 是次数

字符串的连接 join

字符串.join(列表） #括号汇总的内容主要是列表，可以是其他容器

# 作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串

-列表中的数据使用 逗号 隔开

-注意点：列表中的数据必须都是字符串，否则会报错

列表

列表 List，是使用最多的一种容器（数据类型）

列表中可以存储多个数据，每个数据之间使用逗号隔开

列表中可以存放任意类型的数据

列表支持下标和切片

列表支持下标和切片操作，使用方法和字符串中的使用方法一致，

区别：列表的切片得到的是列表

列表：增删改查

查找-查找列表中数据下标的方法

在字符串中使用的 find 方法查找下标的，不存在返回值是 -1.

在列表中没有 find 方法，想要查找数据的下标，使用的是 index() 方法

列表.index(数据， start,  end)  使用和find 方法一样，同时在字符串中也有 index 方法

区别： 返回， index() 方法，找到第一次出现的下标， 没有找到代码直接报错

查找-判断是否存在

判断容器中某个数据是否存在可以使用 in 关键字

数据 in 容器  # 如果存在返回 True ，如果不存在，返回 False

查找-统计出现的次数

统计出现的次数，使用的是 count() 方法

列表.count(数据)  #返回 数据出现的次数

添加数据的方法

尾部添加（最常用）

列表.append(数据）  # 将数据添加到列表的尾部

返回：返回的 None（关键字，空），一般就不再使用 变量 来保存返回的内容

想要查看添加后的列表，需要打印的是列表

指定下标位置添加

列表.insert(下标，数据） # 在指定下标位置添加数据，如果指定的下标位置本来有数据，

原数据会后移

返回：返回的 None（关键字，空），一般就不再使用 变量 来保存返回的内容

想要查看添加后的列表，需要打印的是列表

列表合并

列表1.extend(列表2)  # 将列表 2 中的所有数据逐个添加在列表 1 的尾部

修改操作

想要修改列表中的指定位置的数据，使用的语法是：

列表[下标] = 数据

# 字符串中字符不能使用下标修改

删除操作

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

根据下标删除

列表.pop(下标）   # 删除指定下标对应的数据

1. 下标不写，默认删除最后一个数据（常用）

2. 书写存在的下标，删除对应下标的位置的数据

返回： 返回的删除的数据

根据数据值删除

列表. remove(数据值）   # 根据数据值删除

返回： None

注意：如果要删除的数据不存在，会报错

清空数据（一般不用）

列表. clear()

列表的反转（倒置）

字符串中 反转倒置： 字符串[::-1]

列表中 反转和倒置：

1.列表[::-1]  # 使用切片的方法，会得到一个新列表，原列表不会发生改变

2.列表.reverse()  # 直接修改原列表，返回 None

列表的复制

将列表中的数据复制一份，给到一个新的列表

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

1.使用切片

变量 = 列表[:]

2. 使用 copy 方法

变量 = 列表.copy()

列表的排序

列表的排序， 一般来说都是对数字进行排序的

列表.sort()  # 按照升序排序，从小到大

列表.sort(reverse=True)  # 降序排序， 从小到大

列表的嵌套

列表嵌套，列表中的内容还是列表

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

元组

元组：tuple, 元组的特点和列表非常相似

1.元组中可以存放任意类型的数据

2.元组中可以存放任意多个数据

区别：

1.元组中的数据内容不能改变，列表中的数据是可以改变的

2.元组使用（），列表 使用[]

应用：在函数的传参或者返回值中使用，保证数据不会被修改

定义：

1.使用 类实例化的方式

2.直接使用（）方式

常用方法：

由于元组中的数据不能修改， 所以只有查看的方法

1. 在元组中也可以使用 下标 和 切片 获取数据

2. 在元组中存在 index 方法，查找下标，如果不存在，会报错

3. 在元组中可以使用 count 方法，统计数据出现的次数

4. 在元组中可以使用 in 操作，判断数据是否存在

5. len() 统计个数

以上方法的使用 和 列表中是一样的

字典

1. 字典 dict, 字典中的数据是由键（key）值（value）对组成的（键表示数据的名字，值就是具体的数据）

2. 在字典中一组键值对是一个数据，多个键值对之间使用 逗号 隔开

变量 = {key: value, key:value, ...}

3. 字典中的键 一般都是 字符串，可以是数字， 不能是列表

增加和修改操作

语法：

字典[键] = 数据值

1. 如果键已经存在，就是修改数据值

2.如果键不存在，就是添加数据（即添加键值对）

删除

删除指定键值对

del 字典[键] 

字典.pop(键） # 键必须书写  

清空

字典.clear()

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

字典中没有下标的概念，想要获取数据值，要使用 key(键）来获取

使用 字典[键]

字典[键]

1. 如果键存在，返回键对应的数据值

2. 如果键不存在，会报错

使用  字典.get(键）

字典.get（键， 数据值)

1. 数据值一般不写，默认是 None

返回：
1.如果键存在，返回键对应的数据值

2.如果键不存在，返回的是 括号中书写的数据值（None）

一般使用 get 方法

字典的遍历

对 字典 的键进行遍历

for 变量 in 字典：

      print(变量）  # 变量就是字典的 key ，键

for 变量 in  字典.keys():   # 字典.keys()  可以获取字典中所有的键

     print(变量） 

对  字典的值 进行遍历

for 变量 in 字典.values():   # 字典.values() 可以获取字典中所有的值

     print(变量）

对 字典的键值对 进行遍历

# 变量1  就是 键，变量2 就是键对应的值

for 变量1，变量2 in 字典.items():   # 字典.items() 获取键值对

     print(变量1，变量2）

容器部分 总结

1. 字符串， 列表， 元组 支持加法运算

str1 = ' hello ' + ' world '   #  ' hello world '

list1  =  [1 , 2] + [3, 4]    #[1, 2, 3, 4]

tuple1 = (1, 2) + (3, 4)   #(1, 2, 3, 4)

# 2. 字符串 列表 元组 支持 乘一个数字

' hello ' * 3  # ====>  'hello hello hello '

[1 , 2] * 3 #  ====> [1, 2, 1, 2, 1, 2]

(1, 2)  *3  # ====> (1, 2, 1, 2, 1, 2)

# 3. len() 在 容器中都可以使用

# 4. in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在

列表 添加 用的多

函数

print()

input() ----> str

type()  

概念

函数好处：减少代码的冗余（重复的代码不用多写），提高程序的编写效率

函数定义

1. 将多行代码放在一块，起名字的过程

2. 函数必须先定义后调用

语法

       def 函数名（）：

               函数中的代码

               函数中的代码

# 1. def 是关键字，用来定义函数的 define 的缩写

# 2. 函数名需要遵守标识符的规则

# 3. 处于 def 缩进中的代码，称为函数体

# 4. 函数定义的时候，函数体中的代码不会执行，在调用的时候才会执行

函数定义小技巧

在前期，书写不熟练的时候，

1. 可以先不管函数，先把功能写出来，

2. 给多行代码起名字

3. 选中多行代码，使用 tab 键进行缩进

函数的调用

1. 使用多行代码的时候，称为调用

语法

函数名（）

# 1. 函数调用的时候会执行函数体中的代码

# 2. 函数调用的代码，要写在 函数体外边

文档注释

文档注释的本质，还是注释，只不过书写的位置和作用比较特殊

1. 书写位置，在函数名的下方使用 三对双引号进行的注释

2. 作用： 告诉别人这个函数是如何使用的

3. 查看， 在调用的时候，将光标放到函数名上，使用快捷键 Ctrl q(Windows)

ctrl B 转到函数申明中查看（按住Ctrl 鼠标左键点击）

函数的嵌套调用

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

1.函数定义不会执行函数体中的代码

2.函数调用会执行函数体中的代码

3.函数体中代码执行结束会回到函数被调用的地方继续向下执行

今日内容

补充：列表去重

函数基本知识（返回值（返回）），参数）

变量进阶（理解，Python 底层原理，面试题）

函数进阶（返回值，参数）

列表去重

列表去重：列表去重：列表中存在多个数据，需求，去除列表中重复的数据。

方式1. 思路

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

遍历： for 循环实现

判断是否存在： 可以使用 in

存入数据： append()  

方法2：

在 Python 中还有一种数据类型（容器），称为是 集合（set）

特点：集合中不能有重复的数据（如果 有重复的数据会自动去重）

可以使用集合的特点对列表去重

1. 使用 set() 类型转换将列表转换为 集合类型

2. 再使用 list() 类型转换将集合 转换为列表

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

函数的返回值

函数的返回值，可以理解为是 函数整体执行的结果是什么

什么时候需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据作为返回值返回，以供后续使用

print()   --->  None

input()  ----> 键盘输入的内容

type()   ------> 类型

len()    -------> 数据的长度（元素的个数）

在函数中想要一个数据作为返回值 返回，需要使用 return 关键字（只能在函数中使用）

作用：

1.  将数据值作为返回值返回

2. 函数代码执行遇到 return ，会结束函数的执行

返回值的说明

def 函数名（）：  # 返回值 None

      pass  # 代码中没有 return 

def 函数名（）：

      return   # return  后边没有数据，返回值 None

def 函数名（）：

      return **   # 返回值是**

变量进阶[进阶]

在这一部分  我们了解 Python 底层是如何处理数据的

变量的引用

1. 在定义变量的时候， 变量 = 数据值，Python 解释器会在内存中开辟两块空间

2. 变量和数据都有自己的空间

3. 日常简单理解，将数据保存到变量的内存中，本质是将数据的地址保存到变量对应的内存中

4. 变量中存储地址的行为 就是引用（变量引用了数据的地址，简单来说就是变量中存储数据）

存储的地址  称为  引用地址

5. 可以使用 id() 来获取变量中的引用地址（即数据的地址），如果两个变量的id()获取的引用地址一样，即代表着，两个变量引用了同一个数据，是同一个数据

6.只有 赋值运算符= ，可以改变变量的引用（等号左边的数据的引用）

7. python 中数据的传递，都是传递的引用

可变类型和不可变类型

数据类型： int float bool str list tuple dict set

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

不允许被修改就是不可变类型（不使用 = ，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的）

可变类型：列表 list , 字典 dict ,集合 set   (剩下的都是不可变类型）

           列表.append()

           字典.pop(键)

不可变类型：int float bool str tuple

重要面试题1：

重要面试题2：

组包和拆包

组包（pack）:将多个数据值使用逗号连接，组成元组

拆包（unpack）:将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持一致

复制运算符，都是先执行等号右边的代码，执行的结果，保存到等号左边的变量中

局部变量和全局变量

变量：根据变量的定义位置，可以将变量分为局部变量和全局变量

局部变量

局部变量：在函数内部（函数的缩进中）定义的变量，称为是局部变量

特点：

1. 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用

2. 在不同函数中，可以定义名字相同的局部变量，两者之间没有影响

3.生存周期（生命周期，作用范围）-->在哪 能用

在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用

所以函数中的局部变量的值，如果想要在函数外部使用，需要使用 return 关键字，将这个值进行返回

全局变量

定义位置：在函数外部定义的变量，称为是 全局变量

特点：

1. 可以在任何函数中读取（获取）全局变量的值

2. 如果在函数中存在和全局变量名字相同的局部变量，在函数中使用的是局部变量的值（就近）

3. 在函数内部想要修改全局变量的引用，需要添加 global 关键字，对变量进行声明为全局变量

4.  声明周期

代码执行的时候被创建，代码执行结束，被销毁（删除）

函数进阶

返回值-函数要返回多个数据值

函数中想要返回一个数据值，使用 return 关键字

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

函数参数

形参的不同书写方法

函数传参的方式

位置传参

       在函数调用的时候，按照形参的顺序，将实参值传递给形参

关键字传参

       在函数调用的时候，指定数据值给到那个形参

混合使用

       1.关键字传参必须写在位置传参的后面

       2. 不要给一个形参传递多个数据值

缺省参数

缺省参数，默认参数

列表.pop()  # 不写参数，删除最后一个

列表.sort(reverse = True)

1. 定义方式

在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数，注意，缺省参数的书写要放在普通参数的后边

2.特点（好处）

缺省参数，在函数调用的时候，可以传递实参值，也可以不传递实参值

如果传参，使用的就是传递的实参值，如果不传参，使用的就是默认值

多变参数[可变参数/不定长参数]

print（1）

print（1，2）

print（1，2，3）

print（1，2，3，4）

当我们在书写函数的时候，不确定参数的具提个数时，可以使用 不定长参数

不定长位置参数（不定长元组参数）

1. 书写，在普通参数的前边，加上一个 * ，这个参数就变为不定长位置参数

2. 特点，这个形参可以接收任意多个 位置传参 的数据

3. 数据类型，形参的类型是 元组

4. 注意，不定长位置参数 要写在普通的参数后面

5. 一般写法，不定长位置参数的名字为 args ,即（*args） # arguments

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

1. 书写，在普通参数的前边，加上 两个 * ，这个参数就变为不定长关键字参数

2. 特点， 这个形参可以接收任意多个 关键字的数据

3. 数据类型，形参的类型是 字典

4. 注意，不定长关键字参数，要写在所有参数的后边

5. 一般写法， 不定长关键字参数的名字为 kwargs ，即（**kwargs）， keyword arguments

完整的参数顺序

def 函数名（普通函数，*args，缺省参数，**kwargs）:

      pass

# 一般在使用的时候，使用1-2 种，按照这个顺序挑选书写即可

形参 是属于局部变量的

今日内容

函数部分

      不定长参数的补充扩展

      匿名函数 lambda

面向对象

函数

不定长参数补充

匿名函数

匿名函数：就是使用 lambda 关键字定义的函数

一般称为使用 def 关键字定义的函数为，标准函数

匿名函数只能书写一行代码

匿名函数的返回值不需要 return,一行代码（表达式） 的结果就是返回值

语法

lambda 参数：一行代码  # 这一行代码，称为是表达式

# 匿名函数一般不需要我们主动的调用，一般作为函数的参数使用

# 我们在学习阶段为了查看匿名函数定义的是否正确，可以调用

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

变量 = lambda 参数： 一行代码

# 2，使用变量进行调用

变量（）

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

 字符串比大小，是比较字符对应的 ASCII 码值

A < Z < a < z

ord(字符）  # 获取字符对应的 ASCII 的值

chr(ASCII 值)   #  获取对应的 字符

字符串比大小：

对应下标位置字符的大小，直到全部比完了，还没有比出大小，就是相等

面向对象

基本的介绍

面向对象是一个编程思想（写代码的套路）

编程思想：

1. 面向过程

2. 面向对象

以上两种都属于写代码的套路（方法）,最终目的都是为了将代码书写出来，只不过过程和思考方法不太一样。

面向过程：

       关注的是 具体步骤的实现，所有的功能都自己书写

       亲力亲为

       定义一个函数，最终按照顺序调用函数

面向对象：

       关注的是结果，谁（对象）能帮我做这件事

       偷懒

       找一个对象（），让对象去做

类和对象

面向对象的核心思想是 找一个对象去帮我们处理事情

在程序代码中 对象 是由 类 创建的

类和对象，是 面向对象 编程思想中非常重要的两个概念

类

      抽象的概念，对 多个 特征 和行为相同或者相似事物的统称

      泛指的（指代多个，而不是具体的一个）

对象

      具体存在的一个事物，看得见摸得着的

      特指的（指代一个）

类的组成

1. 类名（给这多个事物起一个名字，在代码中 满足大驼峰）

2. 属性（事物的特征，一般文字中的名词）

3. 方法（事物的行为，即做什么事，一般是动词）

类的抽象（类的设计）

类的抽象，其实就是找到 类的 类名，属性 和方法

面向代码的步骤

1. 定义类，在定义类之前先设计类

2. 创建对象，使用第一步定义的类创建对象

3. 通过对象调用方法

面向对象基本代码的书写

1.定义类

先定义简单的类， 不包含属性，在 python 中定义类需要使用关键字 class

方法：方法的本质是在类中定义的函数， 只不过，第一个参数是 self

class 类名：

         # 在缩进中书写的内容，都是类中的代码

         def 方法名（self）： # 就是一个方法

                     pass

2. 创建对象

创建对象是使用 类名（）进行创建，即

类名（）   # 创建一个对象，这个对象在后续中不能使用

# 创建的对象想要在后续的代码中继续使用，需要使用一个变量，将这个对象保存起来

变量 = 类名（）# 这个变量中欧 保存的是对象的地址，一般可以成为这个变量的对象

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

3.调用方法

对象.方法名（）

列表.sort()

列表.append()

self 的说明

1. 从函数的语法上讲， self是形参，就可以是任意的变量名，只不过我们习惯将这个形参写作   self

2. self 是普通的形参，但是在调用的时候没有传递实参值， 原因是，Python 解释器在执行代码的时候，自动的将调用这个方法的对象 传递给了 self ，即 self 的本质是对象

3.验证，只需要确定 通过哪个对象调用，对象的引用和 self 的引用是一样的

4. self 是函数中的局部变量，直接创建的对象是全局变量

对象的属性操作

添加属性

对象.属性名 = 属性值

类内部添加

        在内部方法中， self 是对象

        self.属性名 = 属性值

        # 在类中添加属性一般写作 _init_ 方法中

类外部添加

        对象.属性名  = 属性值  #  一般不使用

获取属性

对象.属性名

类内部

         在内部方法中， self 是对象，

         self.属性名

类外部

         对象.属性名  # 一般很少使用

魔法方法

python 中有一类方法，以两个下划线开头，两个下划线结尾，并且在满足某个条件的情况下，会自动调用，这类方法称为 魔法方法

学习：

1. 什么情况下自动调用

2. 有什么用，用在哪

3. 书写的注意事项

__init__方法 ** 

1. 创建对象之后会自动调用

2. ①给对象添加属性的（初始化方法，构造方法） 多

    ②某些代码，在每次创建对象之后，都要执行，就可以将这行代码写在_init_方法

3. ①不要写错了

    ②如果 init 方法中，存在了 self 之外的参数，在创建对象的时候必须传参

__str__方法 *

1. 使用 print(对象） 打印对象的时候 会自动调用

2. ①在这个方法中一般书写对象的属性信息的，即打印 对象的时候想要查看什么信息，在这个方法中进行定义的

    ②如果类中没有定义 __str__方法 ， print(对象)，默认输出对象的引用地址

3.这个方法必须返回 一个字符串

__str__方法 （了解）

__init__方法，创建对象之后，会自动调用 (构造方法）

__del__方法，对象被删除销毁时，自动调用的（遗言，处理后事）（析构方法）

1.调用场景，程序代码运行结束，所有对象都被销毁

2.调用场景，直接使用 del 删除对象（如果对象有多个名字（多个对象引用一个对象），需要把所有的对象都删除才行

今日内容

封装（定义类的过程）

       案例（存放家具）

继承

多态

封装的补充

     私有和公有权限

     属性的分类（实例属性，类属性）

     方法的分类（实例方法，类方法，静态方法）

私有和公有

1. 在 Python 中定义的方法和属性，可以添加访问控制权限（即在什么地方可以使用这个属性和方法）

2. 访问控制权限分为两种， 公有权限，私有权限

3. 公有权限

        直接书写的方法和属性，都是公有的

        公有的方法和属性，可以在任意地方访问和使用

4. 私有权限

        在类内部，属性名 或者方法名 前边加上两个下划线，这个 属性或者方法 就变为 私有的

        私有的方法和属性，只能在当前类的内部使用

5. 什么时候定义私有

       ① 某个属性或者方法，不想在类外部被访问和使用，就将其定义为私有即可

       ② 测试中，一般不怎么使用，直接公有即可

       ③ 开发中，会根据需求文档，确定什么作为私有

继承

1. 继承描述的是类与类之间的关系

2. 继承的好处：减少代码的冗余（相同的代码不需要多次重复书写，可以直接使用）

# class A(object):
class A:   # 没有写父类，object, object 类是 Python 中最顶级（原始）的类
   pass

class B(A):   # 类 B, 继承类 A
   pass

术语：

1. A 类，称为是 父类

2. B 类，称为是 子类

单继承：一个类只继承一个父类，称为单继承

继承之后的特点：

      子类（B）继承父类（A）之后，子类的对象可以直接使用父类中定义的公有属性和方法

重写

重写：在子类中定义了和父类中名字相同的方法，就是重写

重写的原因：父类中的方法，不能满足子类对象的需求，所以重写

重写之后的特点：调用子类的方法，不再调用父类中的方法

重写的方式：

       1. 覆盖（父类中功能完全抛弃，不要，重新书写）

       2. 扩展（父类中功能还调用，只是添加一些新的功能） （使用较多）

覆盖

1. 直接在子类中 定义和父类中名字相同的方法

2. 直接在方法中书写新的代码

扩展父类中的功能

1. 直接在子类中 定义 和父类名字相同的方法

2. 在合适的地方调用 父类中的方法 super（）.方法（）

3. 书写添加新的功能

多态（了解）

1. 是一种写代码，调用的一种技巧

2. 同一个方法，传入不同的对象，执行得到不同的结果，这种现象称为是多态

3. 多态 可以 增加代码的灵活度

哪个对象调用方法，就去自己的类中查找这个方法，找不到去父类找

属性和方法

Python 中一切皆对象。

即 使用 class 定义的类 也是一个对象

对象的划分

实例对象（实例）

1. 通过 类名（）创建的对象，我们称为实例对象，简称实例

2. 创建对象的过程称为是类的实例化

3. 我们平时所说的对象就是指 实例对象（实例）

4. 每个实例对象，都有自己的内存空间，在自己的内存空间中保存自己的属性（实例属性）

类对象（类）

1. 类对象 就是 类，或者可以认为是 类 名

2. 类对象是 Python 解释器在执行代码的过程中 创建的

3. 类对象的作用：① 使用类对象创建实例  类名（），② 类对象 也有自己的内存空间，

可以保存一些属性值信息（类属性）

4. 在一个代码中，一个类 只有一份内存空间

属性的划分

实例属性

概念：

        是 实例对象 具有的属性

定义和使用：

        在 init 方法中，使用 self.属性名 = 属性值 定义

        在方法中是 使用 self.属性名 来获取（调用）

内存：

        实例属性，在每个实例中 都存在一份

使用时机：

         1.基本上 99% 都是实例属性，即通过 self 去定义

         2.找多个对象，来判断这个值是不是一样的，如果都是一样的，同时变化，则一般定义为类属性，否则定义为  实例属性

类属性

概念：

         是 类对象 具有的属性

定义和使用：

         定义：在类内部，方法外部，直接定义的变量，就是类属性

         使用：类对象.属性名 = 属性值 or 类名.属性名 = 属性值

                    类对象.属性名               or  类名.属性名

内存：

        只有   类对象  中 存在一份

方法的划分

        方法，使用 def 关键字定义在类中的函数就是方法

实例方法（最常用）

        定义：

# 在类中直接定义的方法 就是 实例方法
class Demo
    def  func(self):   # 参数一般写作 self,表示的是实例对象
         pass

         定义时机（什么时候用）：

         如果在方法中需要使用实例属性（即需要使用  self ），则这个方法必须定义为 实例方法

         调用：

         对象.方法名（）  # 不需要给 self 传参

类方法（会用）

        定义：

# 在方法名字的上方书写 @classmethod 装饰器（使用 @classmethod 装饰的方法）
class Demo:
     @classmethod
     def func(cls):   # 参数一般写作 cls, 表示的是类对象（即类名） class
         pass

           定义时机（什么时候用）：

           1. 前提，方法中不需要使用 实例属性（即 self）

           2. 用到了类属性，可以将这个方法定义为类方法（也可以定义为实例方法）

           调用：

           # 1. 通过类对象调用

           类名.方法名（）       # 也不需要给 cls 传参，python 解释器自动传递

           #  2. 通过实例对象调用

           实例.方法名（）       # 也不需要给 cls 传参，python 解释器自动传递

静态方法（基本不用）

          定义：

# 在方法名字的上方书写 @staticmethod 装饰器（使用 @staticmethod 装饰的方法）
class Demo:
      @staticmethod
      def func():   #一般没有参数
          pass

            定义时机（什么时候用）：

            1. 前提，方法中不需要使用 实例属性（即 self）

            2. 也不使用类属性，可以将这个方法定义为  静态方法

 调用：

           # 1. 通过类对象调用

           类名.方法名（）  

           #  2. 通过实例对象调用

           实例.方法名（）    

补充

哈希（hash）：是一个算法，可以对数据产生一个唯一的值（指纹）

is 可以用来判断两个对象是不是同一个对象，即 两个对象 的引用是否相同

a is b ===>  id(a) ==id(b)

面试中可能会问： is 和 == 的区别？

== 只判断数据值是否相同， is 判断引用是否相同

今日内容

文件操作

       普通文件的操作

       json文件的操作[重点]

异常处理（程序代码运行时的报错 ）

文件介绍

计算机的 文件，就是存储在某种 长期储存设备 上的一段 数据

作用：将数据长期保存下来，在需要的时候使用

1. 计算机只认识 二进制（0  1）

2. 文件中存储的数据都是以二进制（0  1）的形式去存储的

可以根据  文件中的二进制 内容，能否使用记事本软件 将其转换为文字，将文件

分为两种：文本文件和二进制文件

文件操作

文件操作的步骤

1. 打开文件

2. 读或者写文件

3. 关闭文件

1.打开文件

2.读或者写文件

3.关闭文件

使用 with open 打开文件

with open() 打开文件的好处：不用自己去书写关闭文件的代码，会自动进行关闭

with open(file, mode, encoding='utf-8') as 变量：
     # 在缩进中去读取或者写入文件

# 缩进中的代码执行结束，出缩进之后，文件会自动关闭

按行读取文件内容

按行读取文件：一次读取一行内容

文件对象.readline()

json 文件的处理

json 文件 也是一个文本文件，就可以直接使用 read() 和 write() 方法

去操作文件，只是使用这两个方法，不方便，所以对 json 文件有自己独特的读取和写入的方法

常用在 在做测试的时候，将测试数据定义为 json 文件格式，使用 代码 读取 json 文件，即读取测试数据，进行传参（参数化）

json的介绍

json 基于文本，独立于语言的轻量级的数据交换格式

      基于文本，是一个文本文件，不能包含图片，音视频等

      独立于语言，不是某个语言特有的，每种编程语言都可以使用

      轻量级，相同的数据，和其他格式相比，占用的大小比较小

      数据交换格式，后端程序员 给前端的数据（json, html, xml）

json文件的语法

1. json 文件的后缀是.json

2. json 中主要数据类型为 对象（{}  类似 Python 中 字典） 和 数组（[]，类似 Python 中列表），

    对象 和 数组 可以互相嵌套

3. 一个json 文件是一个 对象或者数组（即 json 文件的最外层要么是一个{}，要么是一个 数组[]）

4. json 中的对象是由键值对组成的，每个数据之间使用 逗号 隔开，但是最后

一个数据后边不要写逗号

5. json 中的字符串 必须使用 双引号

6. json 中的其他数据类型

       数字类型 -----> int float

       string字符串 ------> str

       布尔类型 true, false ---->True，False

       null ------> None

json 文件的书写

读取 json 文件

1. 导包 import json

2. 读打开文件

3. 读文件

json.load(文件对象）

# 返回的是 字典（文件中是对象）或者列表（文件中是数组）

json 的写入

文件对象.write(字符串)    不能直接将 Python 的列表 和字典 作为参数传递

想要将 Python 中的数据类型存为 json 文件，需要使用 json 提供的方法，

不再使用 write

步骤：

1. 导包

2. 写(w) 方式打开文件

3. 写入

json.dump(Python 中的数据类型，文件对象)

异常

程序在运行时，如果 Python 解释器 遇到一个错误，会停止程序的执行，并且提示一些错误信息，这就是异常

程序停止执行并且提示一些错误信息 这个动作，抛出异常（raise 关键字）

捕获异常：程序遇到异常，默认动作是终止代码程序的运行，遇见异常之后，

可以使用 异常捕获，让程序代码继续执行，不会终止运行（重点）

异常捕获[重点]

基本语法

捕获指定类型的异常

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

异常捕获的完整版本

完整版本中的内容，不是说每一次都要全部书写，根据自己的需要，去选择其中的进行使用

今日内容 

异常

异常传递[了解]

异常传递是 Python 中已经实现好了，我们不需要操作，我们知道异常会进行传递。

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

def func1():
    num = 10 / 0
    print(num)
    
def func2():
    print('1111')
    func1()

try:
    func2()
except Exception as e:
    print(e)

模块和包

         导入模块（导包）   

if _name__ -- "_main_":

1. Python 源代码文件就是一个模块

2. 模块中定义的变量 函数 类，都可以让别人使用，同样，可以使用别人定义的（好处：别人定义好的不需要我们再次书写，直接使用即可）

3. 想要使用 别人的模块中的内容工具（变量，类，函数），必须先导入模块 才可以

4. 我们自己写的代码，想要作为模块使用，代码的名字需要满足标识符的规则（由数字，字母，下划线组成，不能以数字开头）

导入模块的语法

方式一（重点使用）

import 模块名
# 使用模块中的内容
模块名.工具名

# 举例
import random
import json
random.randint(a, b)
json.load()
json.dump()

方式二（主要用快捷方式导包）

from 模块名 import 工具名
# 使用
工具名  # 如果是函数和类需要加括号

# 举例
from random import randint
from json import load, dump
randint(a, b)
load()
dump()

快捷导包

方式三[了解]基本不用

from 模块名 import  # 将模块中所有内容都导入

from random import 
from json import

randint(a, b)
load()
dump()

对于导入的模块和工具可以使用 as 关键字给其起别名

注意：如果起别名，原来的名字就不能用了，只能使用别名

# 方式一
# import random

# print(random.randint(1, 20))

# 方式二
# from random import randint

# print(randint(1, 20))

# 方式三
from random import

print(randint(1, 20))

模块的查找顺序

在导入模块的时候，会在当前目录中找模块，如果找到，就直接使用

如果没有找到，回去系统的目录中进行查找，找到，直接使用

没有找到，报错

注意点：

定义代码文件的时候，你的代码名字不能和你要导入的模块名字相同

(Unitest框架的学习

         了解，基本组成)

__name__的作用

1. 每个代码文件都是一个模块

2. 在导入模块的时候，会执行模块中的代码（三种方法都会）

3. __name__变量

3.1 __name__变量，是 python 解释器自动维护的变量

3.2 __name__变量，如果代码是直接运行，值是 "__main__"

3.3 __name__变量，如果代码是被导入执行的，值是 模块名（即代码文件名）

 

导包练习

 包（package）

在 Python 中，包 是一个目录，只不过在这个目录中存在一个文件

__init__.py

将功能相近或者相似的代码放在一起

——————————————————

在 Python 中使用的时候，不需要区分包还是模块，使用方式时一样的

random 模块（单个代码文件）

json 包（目录）

unittest 包（目录）

1. import 包名

2. alt   回车 快捷导入

UnitTest框架

介绍

框架

说明：

1.框架英文单词  framework    2. 为解决一类事情的功能集合

需要按照框架的规定（套路）去书写代码

什么是UnitTest框架？

概念：UnitTest是Python自带的一个单元测试框架，用它来做单元测试。

————

自带的框架：不需要单外安装，只要安装了 Python，就可以使用

第三方框架：想要使用 需要先安装后使用（pytest）

_______

单元测试框架：主要用来做单元测试，一般单元测试时开发做的。

对于测试来说，unitest 框架的作用是 自动化脚本（用例代码）执行框架

（使用 unittest 框架 来管理 运行 多个测试用例的）

为什么使用UnitTest框架？

1. 能够组织多个用例去执行

2. 提供丰富的断言方法（让程序代码代替人工自动的判断预期结果和实际结果是否相符）

3. 能够生成测试报告

UnitTest核心要素（unittest的组成）

1.TestCase(最核心的模块）

       TestCase（测试用例），注意这个测试用例是 unittest 框架的组成部分， 

不是手工和自动化中我们所说的用例（Test Case）

主要作用：每个 TestCase(测试用例）都是一个代码文件，在这个代码

文件中 来书写真正的用例代码

2. TestSuite

        TestSuite（测试套间），用来 管理 组装（打包）多个 TestCase(测试用例）的

3. TestRunner

        TestRunner（测试执行，测试运行），用来执行 TestSuite（测试套件）的

4. TestLoader

        TestLoader（测试加载），功能是对 TestSuite（测试套件）功能的补充，

管理 组装（打包）多个 TestCase（测试用例）的

5. Fixture

        Fixture（测试夹具），书写在 TestCase（测试用例）代码中，是一个代码结构，

可以在每个方法执行前后都会执行的内容

举例：

登录的测试用例，每个用例中重复的代码就可以写在 Fixture 代码结构

中，只写一遍，但每次用例方法的执行，都会执行 Fixture 中的代码

1. 打开浏览器

2. 输入网址

TestCase（测试用例）

1. 是一个代码文件，在代码文件中 来书写真正的用例代码

2. 代码文件的名字必须按照标识符的规则来书写（可以将代码的作用在文件的开头使用注释说明）

步骤：

1. 导包（unittest）

2. 自定义测试类，需要继承 unittest 模块中的 TestCase 类即可

3. 在测试类中书写测试方法

4. 执行用例

import unittest

class TestDemo(unittest.TestCase):
    def test_method1(self):
        print('测试方法1')
    
    def test_method2(self):
        print('测试方法2')

问题一 代码文件的命名不规范

1. 代码文件的名字以数字开头

2. 代码文件名字中有空格

3. 代码文件名字有中文

4. 其他的特殊符号

（数字，字母，下划线组成，不能以数字开头）

问题二 代码运行没有结果

右键运行没有  unittest for 的提示，出现的问题

解决方案：

方案1. 重新新建一个代码文件，将写好的代码复制进去

方案2. 删除已有的运行方式

问题三 没有找到用例

测试方法中不是以 test_ 开头的，或者单词写错了

TestSuite & TestRunner

TestSuite（测试套件）：管理 打包 组装 TestCase（测试用例）文件的

TestRunner（测试执行）：执行 TestSuite（套件）

步骤：

1.导包（unittest）

2.实例化（创建对象）套件对象

3.使用套件对象添加用例方法

4.实例化运行对象

5.使用运行对象去执行套件对象

代码：

写法一：

 写法二：

 查看结果：

 

 

 

 

今日内容

unittest框架的组成

       TestLoader

       Fixture

断言

跳过（某些用例由于某些原因）

参数化

测试报告

Unittest组成

TestLoader（测试加载）

TestLoader（测试加载），作用和 TestSuite 的作用是一样的，对 TestSuite 功能的补充，

用来组装测试用例的

比如：如果 TestCase 的代码有很多，（10，20， 30）

使用步骤：

1.导包

2.实例化测试加载对象并添加用例 -------> 得到的是 suite 对象

3.实例化 运行对象

4.运行对象执行套件对象

代码实现

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

Fixture（测试夹具）

Fixture（测试夹具）是一种代码结构

在某些特定的情况下 会自动执行

方法级别[掌握]

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

# 方法执行之前
def setup(self):
    每个测试方法执行之前都会执行
    pass

# 方法执行之后
def teardown(self):
    每个测试方法执行之后都会执行
    pass

类级别[掌握]

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

# 类级别的Fixture 方法，是一个 类方法
# 类中所有方法之前
@classmethod
def setupClass(cls):
    pass

# 类中所有方法之后
@classmethod
def teardownClass(cls):
    pass

模块级别[掌握]

模块：代码文件

在每个代码文件执行前后执行的代码结构

# 模块级别的需要写在类的外边直接定义函数即可
# 代码文件之前
def setupModule():

# 代码文件之后
def teardownModule():
    pass

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

断言

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

断言的结果有两种：

>True，用例通过

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

在 unittest 中使用断言，都需要通过 self.断言方法 来试验

assertEqual

self.assertEqual（预期结果，实际结果）              # 判断预期结果和实际结果是否相等

1. 如果相等，用例通过

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

assertIn 

self.asserIn（预期结果，实际结果）                 # 判断预期结果是否包含在实际结果中

1. 包含，用例通过

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

assertIn('admin', 'admin')    # 包含

assertIn('admin', 'adminnnnn')    # 包含

参数化

参数化 在测试方法中，使用 变量 来代替具体的测试数据，然后使用传参的方法将测试数据传递给方法的变量

好处：相似的代码不需要多次书写

工作中场景：

1. 测试数据一般放在  json  文件中

2. 使用代码读取 json 文件，提取我们想要的数据 -------> [(), ()] or[[],[]]

安装插件

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

-联网安装（在 cmd 窗口安装 ）

  pip install parameterized

_____

pip 是 Python 中包（插件）的管理工具，使用这个工具下载安装插件

验证

pip list # 查看到 parameterized

跳过

对于一些未完成的或者不满足测试条件的测试条件的测试函数和测试类，不想执行，可以跳过

使用方法，装饰器完成

# 直接将测试函数标记成跳过
@unittest.skip('跳过的原因')
# 根据条件判断测试函数是否跳过,判断条件成立，跳过
@unittest.skipIf(判断条件，'跳过原因')

测试报告

自带的测试报告

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

生成第三方的测试报告

1. 获取第三方的 测试运行类模块，将其放在代码的目录中

2. 导包 unittest

3. 使用 套件对象，加载对象 去添加用例方法

4. 实例化 第三方的运行对象 并运行 套件对象