## 1.测试级别
- #### 软件测试流程
#### 单元测试
- 又称模块测试，针对软件设计中的最小单位-程序模块，进行正确性检查的测试工作。单元测试需要从程序内部结构出发设计测试用例。多个模块可以平行地独立进行单元测试。
#### 集成测试
- 又称组装测试，通常在单元测试的基础上，将所有程序模块进行有序的、递增的测试。重点测试不同模块的接口部分。
#### 系统测试
- 指的是将整个软件系统看为一个整体进行测试，包括对功能、性能、以及软件所运行的软硬件环境进行测试。
- 系统测试在系统集成完毕后进行测试，前期主要测试系统的功能是否满足需求，后期主要测试系统运行的性能是否满足需求，以及系统在不同的软硬件环境中的兼容性等。
#### 验收测试
- 验收测试常常有软件系统的购买者代表在现场，甚至是在软件安装使用的现场。这是软件在投入使用之前的最后测试
------
## 2.测试方法
#### 2.1按是否查看源代码分类
- **黑盒测试**
- 又称数据驱动测试，完全不考虑程序内部结构和内部特性，注重于测试软件的功能需求，只关心软件的输入数据和输出数据。
- **白盒测试**
- 关注源代码和程序结构
- **灰盒测试**
- 灰盒测试，是介于白盒测试与黑盒测试之间的一种测试，灰盒测试多用于集成测试阶段，不仅关注输出、输入的正确性，同时也关注程序内部的情况。灰盒测试不像白盒那样详细、完整，但又比黑盒测试更关注程序的内部逻辑，常常是通过一些表征性的现象、事件、标志来判断内部的运行状态。
#### 2.2.按是否运行分类
- **静态测试**
- 指不实际运行被测软件，而只是静态地检查程序代码、界面或文档中可能存在的错误过程。
- **动态测试**
- 是指实际运行被测程序，输入相应的测试数据，检查实际输出结果和预期结果是否相符的过程。
#### 2.3按执行方式
- **手工测试**
- 通过人工手动执行
- **自动化测试**
- 借助自动化工具进行执行
------
## 3.软件质量模型（软件质量特性）
#### 1.功能性
- 提供满足要求的功能
#### 2.可靠性
- 是指在特定条件下使用时，软件产品维持规定的性能级别能力。
- 第一层：设备最好不要出故障；
- 第二层：设备出现故障了不要影响主要的功能和业务；
- 第三层：如果影响了主要功能和业务，系统可以尽快定位并恢复。
#### 3.易用性
- 易懂、易学、易用、漂亮好看（用户体验好）。
#### 4.效率性
- 相对于所用资源的数量，软件产品可提供适当的性能的能力。通常，效率就是我们常说的产品性能。
#### 5.可维持性（可维护性）
- 是指产品可被修改的能力。
#### 6.可移植性
- 是指软件产品从一种环境到另外一种环境的适应能力。（win7、win10、安卓、ios。。。）
## 4.国际标准 ISO-9126软件质量模型
#### 一、功能性
1、适合性：提供了相应的功能
2、准确性：正确（用户需要的）
3、互操作性：产品与产品之间交互数据的能力
4、保密安全性：允许经过授权的用户和系统能够正常的访问相应的数据和信息，禁止未授权的用户访问.......
5、功能性的依从性：国际/国家/行业/企业 标准规范一致性
#### 二、可靠性：产品在规定的条件下，在规定的时间内完成规定功能的能力
1、成熟性：防止内部错误导致软件失效的能力
2、容错性：软件出现故障，自我处理能力
3、易恢复性：失效情况下的恢复能力
4、可靠性的依从性
#### 三、易用性：在指定使用条件下，产品被理解、 学习、使用和吸引用户的能力
1、易理解性
2、易学性
3、易操作性
4、吸引性
5、易用性的依从性
#### 四、效率性：在规定台条件下，相对于所用资源的数量，软件产品可提供适当性能的能力
1、时间特性：平均事务响应时间，吞吐率，TPS（每秒事务数）
2、资源利用性：CPU 内存 磁盘 IO 网络带宽 队列 共享内存
3、效率依从性
#### 五、软件维护性："四规"， 在规定条件下，规定的时间内，使用规定的工具或方法修复规定功能的能力
1、易分析性：分析定位问题的难易程度
2、易改变性：软件产品使指定的修改可以被实现的能力
3、稳定性：防止意外修改导致程序失效
4、易 测试性：使已修改软件能被确认的能力
5、维护性的依从性
#### 六、软件可移植性：从一种环境迁移到另一种环境的能力
1、适应性：适应不同平台
2、易安装性：被安装的能力
3、共存性
4、易替换性
5、可移植性的依从性
## Python基础
#### 格式化字符串
%d 有符号的十进制整数
%06d -- 表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
%.2f,表示小数点后显示的小数位数
print("我是%s" % name)
```python
age=18
print(f'我的年龄是{age}岁') #输出为:我的年龄是18岁
print(r'我的年龄是\n岁') #输出为:我的年龄是\n岁 u
```
```python
#导入random模块
import random
i=random.randint(0,2) #随机生成[0,2]范围的整数,包含0,2
```
find()从左向右寻找子序列的位置,如存在多个相同子序列只返回第一个查找到的位置,如果子序列不存在返回-1.
rfind()从右向左寻找子序列的位置,如存在多个相同子序列只返回第一个查找到的位置,如果子序列不存在返回-1.
#### 列表 list
列表,例:list1=[10,20,30,20,40]
index(数据) #检查某个数据是否存在,存在则返回数据的下表;不存在则报错
append(数据) #列表结尾追加数据
extend() #列表几位追加数据,如果数据是一个序列,则将这个序列的数据拆开,逐一添加到列表
insert(位置下标,数据) #指定位置新增数据
pop(位置下标) #删除指定下标的数据,若不指定下标,则删除最后一个数据;可返回接受删除的数据
remove(数据) #按照指定数据去删除
#### 元组 tuple
元组:一个元组可以存储多个数据,且元组内的数据是不能修改的.
元组,例:tuple1=('a','bc','1','胡大王')
tuple.count('a') #统计元素在元组出现的次数
#### 字典 dict
dict1={} #创建空字典
```
dict1={'name':'Tim','age':20,'gender':'男'}
del dict1['gender'] #结果:{'name':'Tim','age':20}
del dict1 #结果:报错
print(dict1.keys()) #结果:dict_keys(['name', 'age', 'gender'])
print(dict1.values()) #dict_values(['Tim', 20, '男'])
print(dict1.items()) #dict_items([('name', 'Tim'), ('age', 20), ('gender', '男')])
```
字典新增键值对:
```
info_dict={}
info_dict['name']='Tim'
print(info_dict)
#{'name': 'Tim'}
```
del()/del #删除字典或删除字典中指定的键值对
get(key,自定义数据) #如果key存在,返回对应的 value;若key不存在,返回 自定义数据(若无 自定义数据,则返回 None)
keys() #查找字典中所有的key,返回key的可迭代对象
value() #查找字典中所有的value,返回value的可迭代对象
items() #查找字典中所有的键值对,返回键值对的可迭代对象,里面的数据是元组,元组数据1是字典的key,元组数据2是字典key对应的value
#### 集合set
集合,例: set1={10,20,30,40}
集合:不允许数据重复,所以有去重功能;集合没有顺序,没有下标操作
创建集合使用{}或set(),但创建空集合只能使set(): s1=set(),因为{}用来创建字典.
add() #追加的 数据是单一数据,注意是无序的
update() #追加的数据是序列
remove() #删除集合中的指定数据,如果数据不存在则报错
discard() #删除集合中的指定数据,如果数据不存在也不会报错
pop() #随机删除某个数据,并返回这个数据
in: #判断数据在集合序列
not in: #判断数据不在集合序列
```
a=set('abc123你就是弟弟')
print(a)
#结果:{'a', 'c', 'b', '是', '弟', '你', '2', '1', '3', '就'}
b={'abc123你就是弟弟'}
print(b)
#结果:{'abc123你就是弟弟'}
```
#### 四者区别
列表list,例:list1=[10,20,30,20,40]
元组tuple,例:tuple1=('a','bc','1','胡大王')
字典dict,例:dict1={'name':'Tim','age':20,'gender':'男'}
集合set,例: set1={10,20,30,40}
#### 公共操作
| 运算符 | 描述 | 支持的容器类型 |
| :----: | :------------: | :-------------------: |
| + | 合并 | 字符串,列表,元组 |
| * | 复制 | 字符串,列表,元组 |
| in | 元素是否存在 | 字符串,列表,元组,字典 |
| not in | 元素是否不存在 | 字符串,列表,元组,字典 |
| 函数 | 描述 |
| :---------------------------: | :----------------------------------------------------------: |
| len() | 计算容器中元素的个数 |
| del 或del() | 删除 |
| max(),min() | 返回容器中元素最大,最小值 |
| range(start,end,step) | 生成从start到end的数列(不包含end数字),步长为step,供for循环使用 |
| enumerate(可遍历对象,start=0) | 函数用于将一个可遍历的数据对象(如列表,元组或字符串)组合为 一个索引序列,同时列出数据和数据下标,一般用于for循环当中(没有start,则默认start=0) |
```python
range:
for i in range(1,10,2):
print(i) #1 3 5 7 9
for i in range(10):
print(i) #0 1 2 3 4 5 6 7 8 9
list=['a','b','c','d','e']
enumerate:
for i in enumerate(list,start=2):
print(i) #(0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e')
```
#### 推导式
```python
#列表推导式
[xx for xx in rang()]
#字典推导式
{xx1:xx2 for ... in ...}
#集合推导式
{xx for xx in ...}
```
#### 合并两个列表为字典
```python
list1=['name','age','gender']
list2=['Tom',20,'man']
dict1={list1[i]:list2[i] for i in range(len(list1))}
print(dict1) #{'name': 'Tom', 'age': 20, 'gender': 'man'}
```
总结:
1. 如果两个列表数据个数相同,len统计任何一个列表的长度都可以
2. 如果两个列表数据个数不同,len统计数据多的列表数据个数会报错;len统计数据少的列表数据个数不会报错
## 函数基础
#### 修改全局变量
```python
a=100
print(a)
def testA():
print(a)
def testB():
a=200
print(a)
testA() #100
testB() #200
print(f'全局变量a={a}') #100
testA() #100
```
思考:在testB函数内部的a=200中的变量a是在修改全局变量a吗?
答:不是.观察代码发现,11行,12行得到a的数据是100,仍然是定义全局变量a时候的值,而并没有返回testB函数内部的200.综上:testB函数内部的a=200是定义了一个局部变量.
```python
a=100
print(a)
def testA():
print(a)
def testB():
global a #global 关键字声明a全局变量
a=200
print(a)
testA() #100
testB() #200
print(f'全局变量a={a}') #100
testA() #100
```
**global 关键字声明全局变量**
#### 函数的参数
**位置参数**:调用函数时根据函数定义的参数位置来传递参数.
**关键字参数**:函数调用,通过'键=值'形式加以指定.可以让函数更加清晰,容易使用,同时也消除了参数的顺序需求.
**注意**:函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序.
**缺省参数**
**不定长参数**:
包裹位置传递
```python
def user_info(*args): #形参用 *args
print(args)
user_info('胡伟',20,'男') #('胡伟', 20, '男')
user_info() #()
```
**注意**:传进的所有参数都会被args变量收集,根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是**包裹位置传递**.
包裹关键字传递
```python
def user_info(**kwargs):
print(kwargs)
user_info(name='胡伟',age=20,gender='男')
#{'name': '胡伟', 'age': 20, 'gender': '男'}
```
**拆包和交换变量值**
```python
dict1={'name':'Tom','age':21}
a,b=dict1
print(a) #name
print(b) #age
print(dict1[a]) #Tom
print(dict1[b]) #21
```
#### 引用
Python中可变类型和不可变类型详解:
变量对应的值中的数据是不能被修改,如果修改就会生成一个新的值从而分配新的内存空间.
**不可变类型:**
整型(int) (Python2中还有long类型,Python3只有int)
浮点型(float)
布尔(bool)
字符串(string)
元组(tuple)
**可变类型:**
列表(list)
字典(dict)
集合(set )
在python中,值是靠引用来传递来的.
id()判断两个变量是否为同一个值的引用
int不可变类型
list可变类型
**死循环:while True: True的首字母要大写!!**
## 递归
1. 函数内部自己调用自己
2. 必须要有出口
#### lambda表达式
```python
fn1=lambda:100
print(fn1)
#<function <lambda> at 0x000001B9BF441E18> 打印的是lambda内存地址
print(fn1())
#100 fn1()函数调用
```
**默认参数(缺省参数):**如果传入了真实数据,则覆盖默认值;如果不传真实数据,则使用默认值.
**可变参数: ***args 可变不定长参数传入到lambda之后,返回值为元组.
**可变参数: ****kwargs 可变不定长参数传入到lambda之后,返回值为字典.
**列表内字典数据排序**:
```python
students=[
{'name':'Tom','age':20},
{'name':'Rose','age':19},
{'name':'Jack','age':22}
]
students.sort(key=lambda x:x['name'])
print(students)
#[{'name': 'Jack', 'age': 22}, {'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}]
students.sort(key=lambda x:x['age'],reverse=True)
print(students)
#[{'name': 'Jack', 'age': 22}, {'name': 'Tom', 'age': 20}, {'name': 'Rose', 'age': 19}]
```
#### 高阶函数
```python
def sum_num(a,b,f):
return f(a)+f(b)
result=sum_num(-5,9,abs)
#abs是取绝对值函数,是函数名而不是调用式,作为sum_num方法的参数
print(result)
#14
result2=sum_num(1.1,1.3,round)
#round是四舍五入函数
print(result2)
#2
```
map(func,lst),将传入的函数变量func作用到lst变量的每一个元素中,并将结果组成新的列表(Python2)/迭代器(Python3)返回.
```python
list1=[1,2,3,4,5]
def func(x):
return x**2
result=map(func,list1)
print(result)
print(list(result))
```
reduce(func,lst),其中func必须有两个参数.每次func计算的结果继续和序列的下一个元素做累积计算.
filter(func,lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象.如果要转换为列表,可以用list()来转换.
#### 文件操作
文件对象.read(num)
文件对象.readlines()换行会打印输出成\n
文件对象.readline()一次读取一行,换行不会打印输出\n
文件对象.seek(偏移量,起始位置)
|
|
收藏
淘帖
踩
