自动化测试 笔记

自动化测试的优势：
1 完成重复性的工作
2 提升回归测试的效率
3 利用非工作时间执行测试
4 长时间进行稳定性和压力测试
5 保证每次验证的一致性
劣势：
1 不能完成取代手工测试
2 比手工测试更加脆弱
3 脚本执行次数必大于等于5次
4 具备编程能力
什么样的项目适合自动化测试：
1 需求文档不会频繁变更
2 研发和维护周期长，需要频繁的执行回归测试
3 需要多平台运行相同的场景的测试步骤
4 手工测试无法实现的或者成本高的
5 被测软件开发规范，具有可测试性
6 测试人员已经具有编程能力

pycharm

python数据类型

number（数值）string（字符串）tuple（元祖）
stes（集合）list（裂变）drctionary（字典）
前三个不可变类型，后三个可变类型
不可变类型是指想改变数据，必须创建一个新的数据，重新赋予地址和值，可变是地址不变，值可变。
nueber（数值）
int，float，bool（复数）complex（复数）
string
创建字符串可以使用单引号，comple，三单引号和三双引号。其中三双银行可以多行定义字符串。
list（列表）
python中的数据结构是通过某种方式组织在一起的数据元素的集合，这些元素可以是数字，字符，甚至可以是其他数据结构。在python中，最基本的数据结构是序列（列表和元祖）序列中每一个元素都有一个位置（下标，索引）
tuple（元祖）
元祖和列表相似（戴了枷锁的列表） 使用符号（）
set （集合）
集合（set）是一个无序不重复元素的序列，使用大括号{}或者set（）函数创建。
注意：创建一个空集合必须使用set（）而不是{}，因为{}来创建一个空字典
dictionary（字典）
字典是一种映射类型，键值对，字典的关键字必须为不可变类型，却不能重复，创建空字典使用{}。

python数据操作

字符串

s1 = 'hello'
s2 = 'python'
# 拼接
s = s1 + s2
res = s1 * 3
print(s, res)

# 字符串的切片（切片是指在字符串中取出字符）
s3 = 'hello world'
print(s3[1])
print(s3[1:3])
# 索引三之后
print(s3[3:])
# 索引3之前
print(s3[:3])
# 字符串的反转
print(s3[::-1])

# 字符串的格式化
name = 'nick'
age = 18
# 用%占位，后面字符串就跟%s，数字类型就跟%n
s5 = '我的名字是：%s, 我得年龄是：%d' % (name, age)
s4 = '我的名字是：{}, 我得年龄是：{}'.format(name, age)
print(s4)

# 字符串常用的函数
s6 = 'hello pytAhon'
# 计算字符长度
print(len(s6))
# 计算某个字符出现的次数
res = s6.count("l")
print(res)
# 第一个字符大写，其他字符小写
print(s6.capitalize())
# 全部变成小写字母
print(s6.casefold())
# 字符串的替换 replace()第一个参数需要改变的字符，后一个是改变后的字符
print(s6.replace('pytAhon', 'world'))
# 字符串转列表 split（）
s7 = s6.split(' ')
print(s7)

列表

# 列表新增
# 列表新增
list = [1, 2, 3, 4, 5, 'a']
# list.append('d')

# 列表删除d
# 三种方式del列表【索引值】，remove(),pop()
# del list[1]
# list.remove(3)
# list.pop()

# 列表的修改
list[2] = 209
print(list)
#  列表的查询
print(list[2])
# 列表的切片
# 街区中间区值
print(list[1:3])
# 列表反转
print(list[::-1])
# 列表的长度
print(len(list))
l = [1, 7, 3]
# 列表的排序，必须全为数字，有字母会报错sort（）
l.sort()
print(l)
# 统计1元素在列表中出现次数
print(l.count(1))
# 拼接列表成字符串，join（）列表的值必须为字符串
lp = ['1', '2', '3']
lp1 = ['a']
a = ' '.join(lp + lp1)
print(a)

字典

# 字典新增
d = {
    'name': 'nick','age': 19
     }
d['find'] = 'timi'

# 方式2 key值存在不修改value
d.setdefault('aa', 'teacher')

# 字典删除del字典【key】，pop（）指定key，clear（）清空字典，popitem（）删除字典最后一个键值对
del d['age']
# 字典的修改
d['name']= 'ni'
print(d)
# 字典的查询
r = d.get('name')
print(r)
# 字典的常用函数
# 获取字典的键值对数
print(len(d))
# 两个字典的更新（类似于合并）
a1 = {'a': 1}
a2 = {'b': 2}
a1.update(a2)
print(a1)
# 获取字典所有key值
print(d.keys())
# 获取字典所有的value
print(d.values())
# 同时获取key和value
print(d.items())

流程控制语句

# if语句
age = 20
if age > 20:
    print('12')
# if  else语句
if age > 23:
    print(1)
else:
    print(2)
# if elif else
if age > 23:
    print(1)
elif age > 22:
    print(3)
else:
    print(2)
# for循环
# for循环可以遍历任何序列的项目，如一个列表或者一个字符串
lista = [1, 23, 34]
for a in lista:
    print('当前的数字是{}'.format(a))

函数

# 函数
# 函数是以def关键字开头，后面跟函数名和括号  函数可以入参，函数的入参必须放在括号的内部，函数可以使用return返回值，没有return默认返回null,return是结束语句
# 定义
def hello():
    print('hello')
    return 'aaa'
# 调用
res = hello()
print(res)
# 函数的参数调用
# 实参和形参
def jia(a, b):
    print('结果{}'.format(a + b))
jia(1,2)
# 位置参数，是指实参位置和实参位置一致
def say_hello(name, home, age):
    print('大家好，我是{}，我来自{}，今年{}岁'.format(name, home, age))
say_hello('罗森林','衡阳','18')
# 关键字参数  不需要注意位置
def say_hello(name, home, age):
    print('大家好，我是{}，我来自{}，今年{}岁'.format(name, home, age))
say_hello(name='罗森林',age='18',home='衡阳')
# 默认值参数
# 默认值参数必须放在最右边，如果传了实参，那么实参优先，不会使用默认值，默认值只会计算一次，默认值必须是不可变对象
def say_hello(name, home, age=18):
    print('大家好，我是{}，我来自{}，今年{}岁'.format(name, home, age))
say_hello(name='罗森林',home='衡阳')
# 可变参数
# 场景：有时候我们不确定需要传入函数的参数的数量。只要传入就接收并处理。这个时候需要用到不定长参数。不定长参数有两种形式
# 使用*接收任意数量的位置参数  注意：*的不定长参数当做元祖处理
def demo1(my, *name):
    print('大家好，我是{}，下面是我的朋友{}'.format(my,name))
demo1('小罗','a','b','c')
# 使用接收任意数量的关键字参数  注意：**的不定长参数当做字典处理
def demo2(my, **name):
    print('大家好，我是{}，下面是我的朋友'.format(my))
    for i in name.values():
        print(i)
demo2('小罗',a= 1,b=1, c=1)
# 函数的返回值
# ruturn的作用终止函数的执行，所有执行了return后，其后的语句不会被执行
# 如果没有return语句，则默认返回none
# return可以返回一个值，也可以返回多个值，可以返回一个元祖，也可以返回一个字典
# return语句介绍
# return应用
def add(a, b):
    c = a + b
    return c
res = add(1, 2)
print(res)
# lambda匿名函数
# lambda只是一个表达式，函数体比def简单很多
# lambda的主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去
# 虽然lambda函数看起来只有一样，却不等于c或c++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率
add_nmu = lambda a,b:a+b
a11s = add_nmu(1,21)
print(a11s)
# 变量的作用域
# 局部变量
# 在函数内部定义的变量,它的作用域也仅限于函数内部,出了函数就不能使用了,我们将这样的变量称为局部变量.
# 当函数被执行时,puthon会为其分配一块临时的存储空间,所有在函数内部定义的变量,都会存储在这块空间中,而函数执行完毕后,这块临时空间会被释放并回收,所以该空间的变量无法使用
# 全局变量
# global关键字定义全局变量
def demo11():
    global var3
    var3 = '变量3'
    print(var3)
demo11()
print('函数外部{}'.format(var3))

模块导入导出

# 模块导入
# 学习目标  import语句导入模块

import requests
import daochu
from daochu import fun
res = requests.get('http://www.baidu.com/')
print(res)
fun('ni')
# from import语句模块  可以导入函数
# 模块以主程序运行当前模块
# __name__和”__main__“分别是什么？
# 1__name__是当前模块的一个属性，属性名称的前后各有两个_修饰，表明是一个内置属性（或内置变量）
# 2”__main__“分别是什么则是一个字符串对象，一对引号是创建字符串对象的快捷方式
# __name__的属性什么时候等于”main“
# 如果当前是模块的入口模块（也称顶级模块，脚本文件）则当前模块的__name__的属性值是__main__

文件的读取

# 文件读取
# 1 打开文件 2 读取内容  3关闭文件
# 打开文件要使用open内建函数
# open(file[mode='r', encoding=None, errors=None])
# 参数说明：file：文件路径
#         encoding：文件编码方式，不用于二进制文件，一般utf-8.gbk
#         reeors：指定如何处理编码和解码错误，适用于文本文件
#         mode：文件打开模式
#         r只读  w只写 a追加的方式，在原文件继续写，如果存在则追加，不存在则创建新文件 r+可读可写 w+打开一个文件用于读写 b用于二进制文件操作
# 读取文件常用函数：
# rad（[size]）读取文件（读取size字符，默认读取全部）
# readine（【size】）读取一行。如果指定size,将读入指定的字符数）
# readines（）
# f = open('file.txt', mode='r', encoding='utf-8')
# connent = f.readlines()
# print(connent)
# # 关闭文件
# f.close()
# 2with读取文件，可以少写一行关闭文件，with会自动帮我们关闭
with open('file.txt', mode='r', encoding='utf-8') as f:
    for i in f:
# strip()减少字符串之间的空格
        print(i.strip())
# 文件写入
path = 'file.txt'
with open(path, mode='w', encoding='utf-8') as f:
    f.write('你好1')

csv读写

import csv
# csv读取
with open('file.csv')as f:
    csv = csv.reader(f)
    h = next(csv)
    print(h)
# csv写入
# newline不添加等于空，写入的数据会多一个空格
# delimiter="*"用*号做空格
with open('file.csv','w',newline='')as f:
    csv = csv.writer(f.delimiter='*')
    for line in l1:
        csv.writer(line)

异常

# 学习目标  try-except
# try：
#     可能出错的代码
# except:
#     检查到异常，如何处理
# try:
#     1/0
# except :
#     print(1)
# 抛出异常
# raise不带参数，原始报错
# try:
#     1/0
# except ZeroDivisionError as a:
#     print(a)
#     raise ZeroDivisionError('不为0')
# assert抛出异常
# 执行流程：如果条件为假，则抛出AssertionError，为真则通过
# print('start')
# num = int(input('请输入1-9的整数:'))
# assert 0 <num <= 9,'你输入的数字不是1-9'
# print('end')
# 自定义异常：自己定义的异常必须继承BaseException或Exception
# 步骤:1在自定义异常类的构造函数中，调用父类构造函数__init__2重写__str__方法输出异常信息3编写异常处理方法处理异常
class Yichang(BaseException):
    def __init__(self, msg):
        super().__init__()
        self.msg = msg

    def __str__(self):
        return self.msg + '!!!'

try:
    raise CustonError('自定义异常')
except CustonError as e:
    print(e)