黑马程序员技术交流社区

标题: 笔记 [打印本页]

---

作者: 您的戏真多    时间: 2019-7-18 11:49
标题: 笔记
## 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(偏移量,起始位置)

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2