7Python编程语言与测试框架软件测试

软件测试所有内容笔记正在陆续更新中，笔记已经在本地记录，全部为自己手动记录的笔记及总结，正在开始更新中，后续会逐步更新并完善到 软件测试学习内容总结 专栏。
本节内容：Python编程语言与测试框架

1. python环境管理与pip依赖管理

Python介绍

Python历史

Python版本选择

Python的安装

• Python官网：https://www.python.org
• pycharm下载：https://www.jetbrains.com/pycharm/download
• ❓Python和PyCharm环境安装配置：

Linux下Python环境变量配置

• 用vim打开配置文件 vim ~/.bash_profile
• 添加export PATH=$PATH:/usr/local/bin $PATH–表示已经定义好的环境变量拿过来，在后面追加想要添加的环境变量

Linux查看Python环境变量path

$PATH

Mac设置Python3的软连接(默认为Python2)

ln -f /usr/local/bin/python3.8 /usr/local/bin/python

Pycharm

pip 依赖管理

pip help 查看pip帮助文档
pip介绍

• pip是Python中的标准库管理器

• Python3的3.4版本额以及Python2的2.7.9版本开始，pip直接包括在Python的安装包内。

• pypi托管了大量的流行的库 www.pypi.org

• 安装包

  • pip install 包名==版本号 --安装指定版本
    pip install selenium==2.39.0
  • pip install -i 镜像地址 --trusted-host 镜像地址对应的host
    pip3 install jupyter -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

• 国内的pip源
  阿里云：https://mirrors.aliyun.com/pypi/simple
  清华：https://pypi.tuna.tsinghua.edu.cn/simple
  豆瓣：https://pypi.douban.com/simple

• Jupyter安装
  pip install jupyter -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com
  –trusted-host 表示信任镜像源

2. python基本数据类型与操作

• 参考文档
  • Python官方参考文档：https://docs.python.org/3/tutorial/index.html
  • Python经典书籍（进阶）：《流畅的python》 《python cookbook》

id() 打印变量的储存地址
type() 查看变量的数据类型

变量

命名规则

• 字母、数字、下划线 组成，不能以数字开头
• 大小写敏感
• 不能使用关键字，保留字

数字 (Numbers) 与运算符

常用数字类型

• int
• float
• complex

常用运算符

字符串 (String)

• \：转义符
• r：忽略转义符的作用
• +以及空格：多个字符串连接
• 索引
• 切片
  • [start:stop:step]， [开始：结束：步长]
  • 取值范围为前闭后开 [ )

列表 (List)

• 定义
  • 使用中括号包起来的元素叫做列表
  • var_list = [1,2,3,4,5]
• 索引
  • var_list[0]
• 切片
  • var_list[1::-1]

3. python控制流语法

1. Python分支结构

• 分支结构的概念
  

• Python分支结构
  

• 多重分支
  

• 分支嵌套
  

• 练习题
  
  
  

• 哪个写法更好？
  

2. Python 循环结构

循环结构的概念

for-in 循环

• for-in循环
  • 有明确的执行次数时使用
• range函数
  • range 产生不变的数值序列
  • range(101) 0~100
  • range(1,100) 1~199
  • range(1,100,2) 1,3,5,…,99

• 练习题
  
  
  
  

While循环

• 不知道循环次数时使用，产生bool值控制循环，True则执行，False结束
• while else语句

简单语句组

break 和 continue 语句

• break
  • 跳出循环
• continue
  • 跳出当前循环

• 练习题
  
  

4. python函数

1. 函数的定义、调用

• 函数的作用（封装）
  

• 函数的定义

  • 函数说明：三个"""回车自动添加

• 函数的调用
  
  
  
  

2. 函数的各类参数

参数是否还有其他的形式？

• 默认参数
  • 默认参数在定义函数的时候使用k=v的形式定义。
  • 调用函数时，如果没有传递参数，则会使用默认参数；如果传递参数就会使用传递的参数。

def func2(a=1):print(&＃39;参数a的值为：&＃39;,a)func2(2)


• 关键字参数
  
  

• 特殊参数
  
  

3. Lambda 表达式

5. python常用数据结构

1. 列表 [ , ]

• 定义
  • Python中可以通过组合一些值得到多种复合数据类型。
  • 列表是其中最常用的数据结构。
  • 列表通过方括号括起，逗号分隔的一组值得到。
  • 一个列表可以包含不同类型的元素，但通常使用时各个元素类型相同。

列表的特性

• 官网参考：https://docs.python.org/zh-cn/3/tutorial/datastructures.html#list-comprehensions

• list.append(x)：在列表末尾添加一个元素。

  • 相当于 a[len(a):] = [x] 。

• list.insert(i, x)：在给定的位置插入一个元素。第一个参数是索引。

  • a.insert(0,x) 插入列表头部，a.insert(len(a),x) 等同于a.append(x)

• list.remove(x)：移除列表中第一个值为 x 的元素。如果没有这个元素，抛出 ValueError 异常

• list.pop([i])：删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个元素。

• list.sort(key=None,reverse=False)：对列表中的元素进行排序（参数可用于自定义排序，解释请参见 sorted()）

• list.reverse()：反转列表中的元素

• list.clear()：删除列表中的所有元素。相当于del a[:]。
• list.extend(iterable)：使用可迭代对象中的所有元素来扩展列表。相当于a[len(a):] = iterable。
• list.index(x[,start[,end]])：
  • 返回列表中第一个值为 x 的元素的从零开始的索引。如果没有这样的元素将会抛出 ValueError 异常。
  • 可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。
• list.count(x)：返回元素 x 在列表中出现的次数。
• list.copy()：返回列表的一个浅拷贝。相当于 a[:]。

注意：

• insert，remove 或者 sort 方法，只修改列表，没有打印出返回值——它们返回默认值 None。这是Python中所有可变数据结构的设计原则。
• 并非所有数据可以排序或比较（字符串和数字等）

列表推导式

• 概念：列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上，然后使用其结果来创建列表，或者通过满足某些特定条件元素来创建子序列
• 练习：如果我们想生成一个平方列表，比如[1,4,9,…]，使用for循环应该怎么写，使用列表生成式又应该怎么写？

#列表生成式：
list_square = [i ** 2 for i in range(1, 4)]
print(list_square)# for 循环
list_square2 = []
for i in range(1, 4):list_square2.append(i ** 2)
print(list_square2)


list_squre3 = [i ** 2 for i in range(1, 4) if i != 1]
print(list_squre3)list_squre4 = [i * j for i in range(1, 4) for j in range(1, 4)]
print(list_squre4)list_squre4 = []
for i in range(1, 4):for j in range(1, 4):list_squre4.append(i * j)


2. 元祖 (,)

• 元祖使用 () 进行定义
• tuple、list、range都是序列数据类型
• 元祖是不可变的，可以通过解包、索引来访问

# 2 元祖的定义
# type() 打印数据类型
tuple_t = (1, 2, 3)
tuple_t1 = 1, 2, 3print(tuple_t)
print(type(tuple_t))print(tuple_t1)
print(type(tuple_t1))


# 元祖的不可变特性 --变量指针不变
list1 = [1, 2, 3]
list1[0] = &＃39;q&＃39;
print(list1)
tuple1 = (1, 2, 3)
tuple1[0] = &＃39;q&＃39;


# id() 打印变量指针(内存地址)
# 元祖的不可变特性 --&＃39;变量指针&＃39; (内存地址)不变
# 元祖中嵌套列表则可变
a = [1, 2, 3]
tuple1 = (1, 2, a)print(id(tuple1[2]))
tuple1[2][0] = &＃39;a&＃39;
print(id(tuple1[2]))
print(tuple1)


内置函数

# 内置函数
a = (1, 2, 3, 1)
print(a.count(1)) # 计算元素 1 在元祖中出现几次
print(a.index(1)) # 求对应元素的索引
print(a.index(1, 1, 4))
print(a)


3. 集合 {}，set()

• 集合是由不重复元素组成的无序的集
• 它的基本用法包括成员检测和消除重复元素
• 可以使用 {} 或者 set() 函数创建集合
• 要创建一个空集合只能用 set() 而不能使用 {}

# 集合定义
a = {1}
b = set()
print(len(b))
print(type(a))
print(type(b))


# 内置函数
a = {1, 2, 3}
b = {1, 4, 5}
print(a.union(b)) # 并集
print(a.intersection(b)) # 交集
print(a.difference(b)) # 差集 --a有b没有的元素
a.add(&＃39;a&＃39;) # 集合添加元素
print(a)


# 字符串去重后的集合
print({i for i in &＃39;fjajgajdaddahdfdjhgjfaaa&＃39;})
# {&＃39;a&＃39;, &＃39;f&＃39;, &＃39;g&＃39;, &＃39;d&＃39;, &＃39;h&＃39;, &＃39;j&＃39;}c = &＃39;jgirgokafgaaaaa&＃39;
print(set(c)) # {&＃39;i&＃39;, &＃39;k&＃39;, &＃39;g&＃39;, &＃39;r&＃39;, &＃39;a&＃39;, &＃39;o&＃39;, &＃39;f&＃39;, &＃39;j&＃39;}


4. 字典

• 字典是以【关键字】为索引
• 关键字可以是任意不可变类型，通常是字符串或数字。如果一个元祖只包含字符串、数字或元祖，那么这个元祖也可以用作关键字

# 字典定义
dict_d = {&＃39;a&＃39;: 1, &＃39;b&＃39;: 2}
dict_d2 = dict(a=1, b=2)print(dict_d)
print(type(dict_d))
print(dict_d2)
print(type(dict_d2))


print(dict_d.keys()) # 得到所有 key
print(dict_d.values()) # 得到所有 valueprint(dict_d.pop(&＃39;a&＃39;)) # 1；返回value值，并删除key为a的键值对
print(dict_d) # {&＃39;b&＃39;: 2}print(dict_d.popitem()) # popitem()随机删除键值对。返回被删除的键值对
print(dict_d)


a = {}
b = a.fromkeys((1, 2, 3), &＃39;a&＃39;) # 分别把元祖里面的参数当做key值，建立一个新的列表。
print(b) # {1: &＃39;a&＃39;, 2: &＃39;a&＃39;, 3: &＃39;a&＃39;}# 列表推导式
print({i: i * 2 for i in range(1, 3)}) # {1: 2, 2: 4}


6. python模块

项目目录结构

python的程序结构

• 组成：
  • package 包
  • module 模块
  • function 方法
    

模块定义

模块

• 包含Python定义和语句的文件
• .py 文件
• 作为脚本运行

文件引用

模块导入

• import 模块名
• from <模块名> import <方法 | 变量 | 类>
• from <模块名> import *
  • 注意：
    • 同一个模块写多次，只被导入一次
    • import 应该放在代码的顶端

模块分类

• 系统内置模块
• 第三方的开源模块
• 自定义模块

如何使用模块

• 系统内置模块
  • Python自带的一些非常有用的模块（sys，os，time，json模块等）
• 第三方开源模块
  • 通过包管理工具pip完成
• 自定义模块
  • 自己写的模块，对某段逻辑或某些函数进行封装后供其他函数调用

常用方法

• dir()：找出当前模块定义的对象
• dir(sys)： 找出参数模块定义的对象

搜索路径

• Python解析器对模块位置的搜索顺序是 --sys.path查看
  • 包含输入脚本 的目录（如果未指定文件，则为当前目录）
  • PythonPath（目录名称列表，语法与shell变量相同 PATH）
  • 安装的默认路径

使用模块的总结

• 代码的可维护性 --变好
• 提升编码效率
• 函数名不可重复性（起名避免与系统重复）

7. python输入与输出

字面量打印与格式化

字面量

• 字面量(literal)是以变量或常量给出的原始数据。在程序中可以直接使用字面量。
• 字面量类型：
  • 数值型
  • 字符型
  • 布尔型
  • 字面量集合：列表(List)、元祖(Tuple)、字典(Dict)、集合(Set)
  • 特殊字面量：None

字面量插值

• 字面量插值，就是将变量、常量以及表达式插入的一种技术，它可以避免字符串拼接的问题，很多语言都支持了此功能。
• 字面量插值方法：
  • 格式化输出 --’%s,%d,%f ’ %( )
  • 通过string.format()方法拼接 --’{ }’.format( )
  • Formatted string literals，字符串格式化机制（>=Python3.6） --f’{ }’
• https://docs.python.org/3/reference/lexical_analysis.html#f-strings

• 格式化输出
  • %的用法
    

• format()方法
• 用法：str.format() 可以将
  • 字符串 举例：print("we are the {} and {}".format(&＃39;Tom&＃39;,&＃39;Jerry&＃39;))
  • 列表 举例：print(“we are the {0} and {1}”.format(*listdata))
  • 字典 举例：print(“my name is {name}, age is {age}”.format(**dictdata))

• F-strings：字符串格式化机制，支持python3.6以上版本
• 使用方法：f’{变量名}’
• 注意：
  • 大括号里面可以是表达式或者函数
  • 大括号内不能转义，不能使用’ \ ’

文件读取

• 读取文件的操作步骤：
  • 第一步：打开文件，获取文件描述符
  • 第二部：操作文件描述符（读 | 写）
  • 第三部：关闭文件
• 注意：
  • 文件读写操作完成后，应该及时关闭

• open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None,closefd=True, opener=None)
• 参数说明
  • name：文件名称的字符串值
  • mode：只读r，写入w，追加a，默认文件访问模式为只读®
  • buffering：寄存区缓存
    • 0：不寄存
    • 1：访问文件时会寄存行
    • >1寄存区的缓冲大小
    • 负值，寄存区的缓冲大小则为系统默认

======= =====================================
Character Meaning
------------ ---------------------------------------------------------------
&＃39;r&＃39; open for reading (default)
&＃39;w&＃39; open for writing, truncating the file first
&＃39;x&＃39; create a new file and open it for writing
&＃39;a&＃39; open for writing, appending to the end of the file if it exists
&＃39;b&＃39; binary mode
&＃39;t&＃39; text mode (default)
&＃39;+&＃39; open a disk file for updating (reading and writing)
&＃39;U&＃39; universal newline mode (deprecated)
====== ====================================


文件读取

• 文件读取的方法
  • f = open(&＃39;test.txt’方法, ‘r’)
  • f.read()
  • f.close()
• 最优写法：
  • with open(‘file名称’, ‘r’) as f
• 读取文件常用的方法
  • read()    读取文件中的所有内容（缺点：当文件内容非常大，大于内存时，无法使用这个方法）
  • readable()  判断文件是否可读
  • readline()   每次读取一行（包括行结束符），返回的是一个字符串对象，保持当前行的内存
  • readlines()  读取所有行的内容，放到列表中

Json格式转化

Json格式转化

json工具：bejson.com

• Json是什么？
  • 轻量级的数据交换格式
  • 友好，易于读写（比xml，protobuf要好）
  • 对机器友好，易于解析和生成
  • 由列表和字典组成的
• 使用场景
  • 生成：将对象生成为字符串，存入文件，数据库，在网络传输等
  • 解析：解析来自文件，数据库，网络传输的字符串成Python对象
  • 跨语言的数据交换：比如python和c/c++/java/Javascripts的数据交换

Json使用方法

• 如何使用Json？
  • import json
• 常用的几种方法
  • json.dumps(python_obj)  把数据类型转换成字符串
  • json.loads(json_string)   把字符串转换成json
  • json.dump()        把数据类型转换成字符串并存储在文件中
  • json.load(file_stream)    把文件打开，把里面的字符转换成数据类型

tar 解压缩 指定目录加 -C tar -xvf a.tar.gz -C ./a/
查看CPU信息：cat /proc/cpuinfo
负载信息：top

8. python错误与异常

语法错误与定位

division by zero 除数为0
所有异常都继承于BaseException

• 错误

  • 语法错误 -invalid syntax 无效的语法
    • if n > 1，忘加:
  • 逻辑错误
  • 系统错误

• 异常
  

• 异常与错误

  • 异常 -设计的有问题 -捕获
    

常见的异常类型

• 异常类型：
• 常见异常类型：
  • 除零异常 ZeroDivisionError：division by zero 除数为0
  • 名称异常 NameError：name ‘name’ is not defined
  • 索引异常：IndexError：list index out of range
  • 键异常：KeyErro：‘age’
    • dic={&＃39;name&＃39;:&＃39;tom&＃39;} dic[&＃39;age&＃39;]
  • 值异常：ValueError：invalid literal …
  • 属性异常：更改常量值报错

• 异常/错误处理流程
  

异常捕获、异常处理

try except：正常代码写在try下面，接受到异常后在except下面进行处理

def div(a,b):return a/btry:print(div(1,1))list1 = [1,2,3]print(list1[3])
except Exception as e:print(e)


异常捕获与异常处理

使用 raise 抛出异常

自定义异常

class MyError(Exception):def __init__(self,value):self.value = valuedef __str__(self):return repr(self.value)


9. python面向对象编程

1. 什么是面向对象？

两种编程思想

• 面向过程 -将大象装进冰箱要几步
  • 一种以过程为中心的编程思想
  • 简单的事情
• 面向对象 -造汽车
  • 一种更符合我们人类思维习惯的编程思想
  • 面向对象开发就是不断的创建对象，使用对象，操作对象做事情
  • 复杂的事情

什么是面向对象

• 语言层面：封装代码和数据
• 规格层面：对象是一系列可被使用的公共接口
• 从概念层面：对象是某种拥有责任的抽象

面向对象程序设计规则

• 首先分析有哪些类
• 每个类有哪些属性和行为
• 类与类之间存在的关系

2. 类、方法、类变量的定义

类里面创建方法时，要加self
self.name = name
self.name 代表类里面的name，等号后面的name是外面传过来的name
self代表实例

• self.变量名的方式，访问到的变量，叫做实例变量
• 类变量和实例变量的区别
  • 类变量需要类来访问 -Person.name,Perison是类
  • 实例变量需要实例来访问 -zs.name
  • 实例变量和类变量都是可以修改的

print(Person.name)
Person.name = &＃39;tom&＃39; # 修改
print(Person.name)zs = Person(&＃39;张三&＃39;)
print(zs.name)
zs.name = &＃39;lili&＃39; # 修改
print(zs.name)


• 类方法和实例方法的区别
  • 类方法不能访问实例方法，
  • 类方法需要添加一个装饰器 @classmethod
  • 类不能访问类里面的方法，
    • 在需要访问的方法上加装饰器 @classmethod,才可以访问
    • 加了装饰器变成类方法，通过类来访问
    • 类访问方法在编写框架时可能会用到
  • 实例可以访问类里面的方法

Person.eat()
zs = Person(&＃39;张三&＃39;)
zs.eat()


3. 实例引用、实例变量使用

类、实例、方法、变量

• 类(Class)：抽象的概念，一类事物
• 方法：类中定义的函数，对外提供的服务
• 类变量：类变量在整个实例化的对象中是公用的
• 实例引用：实例化一个对象
• 实例变量：以’self.变量名’的方式定义的变量