python自动化测试篇五程序流程控制

最新推荐文章于 2023-03-26 18:30:57 发布

李光洙不会测试

最新推荐文章于 2023-03-26 18:30:57 发布

阅读量1k

点赞数

分类专栏： python自动化测试文章标签： python 自动化软件测试

本文链接：https://blog.csdn.net/weixin_44518506/article/details/124557120

版权

python自动化测试专栏收录该内容

19 篇文章 0 订阅

订阅专栏

python 是通过一些程序结构来控制程序的执行顺序和流程的。

一、程序结构

计算机程序是一条条按顺序执行的指令。顺序结构是是计算机程序的基础，但单一的顺序结构不能解决所有问题。计算机程序由三种基本结构组成：

顺序结构
分支结构
循环结构

1. 顺序结构

我们每天早上起床，穿衣服，洗脸，刷牙，叠被子，吃早餐，这些按照单一顺序进行的就是顺序结构。

顺序结构是程序执行的基本流程，它会按照代码从上往下的顺序依次执行。

a = 1
a += 1
print(a)

例如上面的代码，执行流程为

定义变量 a，并赋值为整数 1
变量 a 自加 1
调用函数 print 输出变量 a 的值
从上往下依次执行

2. 分支结构

出门时是否带伞要根据天气条件进行判断，如果天气好就不带，如果可能下雨或正在下雨就要带，这就是分支结构。

分支结构是程序根据条件判断结果而选择不同代码向前执行的一种方式，也叫条件分支。

分支结构包括：

单分支
二分支
多分支

2.1. 单分支

在 python 中单分支结构通过 if 语句来实现，语法如下：

if <条件>：
    语句块

注意

条件语句结束后要紧跟冒号
语句块是 if 条件满足后执行的一条或多条语句序列
语句块中语句通过缩进与 if 语句所在行形成包含关系
缩进按照规范为 4 个空格

if 语句会首先计算 <条件> 表达式，如果结果为 True 则会执行所包含的语句块，结果为 False 则会跳过所包含的语句块。

if 语句中的语句块的执行与否依赖于条件判断。但无论什么情况，控制都会转到与 if 语句同级别的下一条语句。

在这里插入图片描述

案例：成绩是否及格(1)

在这里插入图片描述
input 函数
input 函数用来接收用户输入的文本信息，然后以字符串的形式返回，它接收字符串参数作为提示信息输出。

score = input('请输入你的成绩>>>:')
print(score,type(score))

请输入你的成绩 >>>:100
100 <class ‘str’>

score = input('请输入你的成绩>>>:')
# 转换类型
score = float(score)
# 判断
if score < 60:
    print('没及格，赏一巴掌')
  
if score >= 60:
    print('有进步，么么哒，亲一下')

请输入你的成绩 >>>:100
有进步，么么哒，亲一下

2.2.二分支

python 中二分支结构通过 if-else 语句来实现的，语法格式如下：

if <条件>:
	<语句块1>
else:
	<语句块2>

< 语句块 1> 是在 if 条件满足后执行的一个或多个语句序列
< 语句块 2> 是 if 条件不满足后执行的语句序列
注意缩进，< 语句块 2> 通过缩进与 else 所在行形成包含关系

二分支语句用于区分 < 条件 > 的两种可能 True 或者 False，分别形成执行路径

在这里插入图片描述

案例：成绩是否及格(2)

通过二分支改进案例成绩是否及格

score = input('请输入你的成绩>>>:')
# 转换类型
score = float(score)
# 判断
if score < 60:
    print('没及格，赏一巴掌')
else:
    print('有进步，么么哒，亲一下')

请输入你的成绩 >>>:100
有进步，么么哒，亲一下

三目运算

二分支结构还有一种更简洁的表达方式，语法格式如下：

<表达式> if <条件> else <表达式2>

适合代码块为 1 行语句时，这种方式也叫三目运算。

上面的代码可以改写为：

score = input('请输入你的成绩>>>:')
# 转换类型
score = float(score)
# 判断

print('没及格，赏一巴掌') if score < 60 else print('有进步，么么哒，亲一下')

请输入你的成绩 >>>:100
有进步，么么哒，亲一下

对于简单判断，三目运算可以将多行语句写成一行，简洁明了。

2.3. 多分支

python 通过 if - elif - else 表示多分支结构，语法如下：

if <条件1>:
	<代码块1>
elif <条件2>:
	<代码块2>
...
else:
	<代码块3>

多分支是二分支的扩展，用于多个判断条件多条执行路径的情况。python 依次执行判断条件，寻找第一个结果为 True 的条件，执行该条件下的代码块，同时结束后跳过整个 if-elif-else 结构，执行后面的语句。如果没有任何条件成立，则执行 else 下的代码块，且 else 语句是可选的，也即是说可以没有 else 语句。

案例：成绩评价

上面的案例对成绩的评价太粗糙了，60 分就可以赏个么么哒。通过多分支改进上面的案例。

请根据用户输入的成绩，按以下等级分区：

< 40: E
40-60: D
60-75: C
75-85: B
85-100: A

score = input('请输入你的成绩>>>:')
# 转换类型
score = float(score)
# 判断
if score < 40:
    print('等级：E')
elif 40<= score < 60:
    print('等级：D')
elif 60<= score < 75:
    print('等级：C')
elif 75<= score < 85:
    print('等级：B')
else:
    print('等级：A')

请输入你的成绩 >>>:100
等级：A

3. 循环结构

工作日每天 9:00 到公司上班，17:30 下班，周而复始，这就是循环结构。

python 中循环结构有两种：

条件循环也叫 while 循环
遍历循环也叫 for 循环

3.1 条件循环

python 中的条件循环通过 while 循环语句来实现，所以也叫 while 循环，语法格式如下：

while <条件>:
	代码块

while 关键字空格后接条件表达式末尾加上冒号组成 while 语句
代码块中的代码通过 4 个空格和 while 语句形成包含关系

while 语句首先计算 <条件> 表达式，如果结果 True，则执行对应代码块中的语句，执行结束后再次执行 <条件>

表达式，再次判断结果，如果为 True 则循环执行，直到 <条件> 表达式为 False 时跳出循环，执行和 while 语句相同缩进的下一条语句。

当 <条件> 表达式恒为 True 时，形成无限循环，也叫死循环，需要小心使用。
在这里插入图片描述

# 依次打印0-9
i = 0
while i < 10:
    print(i)
    i = i + 1

0
1
2
3
4
5
6
7
8
9

# 序列的循环
# 列表的元素循环
ls = ['a','b','c','d','e','f']
index = 0
while index < len(ls):
    print(ls[index])
    index += 1

a
b
c
d
e
f

# 散列的循环
# 集合没办法循环
dc = {'name': 'felix', 'age': 18}
index = 0
# 转换成列表
keys = list(dc.keys())
while index < len(keys):
    print(dc[keys[index]])
    index += 1

felix
18

3.2 遍历循环

python 中使用关键字 for 来实现遍历循环，也叫 for 循环，也叫迭代循环，语法格式如下：

for <循环变量> in <遍历结构>：
	代码块

关键字 for+ 空格 +<循环变量>+ 关键字 in+< 遍历结构 >+ 冒号组成 for 语句
代码块通过缩进和 for 语句形成包含关系

for 循环会依次取出遍历结构中的元素，然后赋值给循环变量，每次遍历都会执行代码块，只到取出遍历结构中的所有元素。

所有可迭代对象都可以作为遍历结构进行 for 循环。

基本数据类型中序列数据类型，散列数据类型都可以进行迭代。

# for循环来遍历可迭代对象非常方便
# 序列的迭代
# 列表的迭代
ls = [0,1,2,3,4,5,6,7,8,9]
for i in ls:
    print(i)

0
1
2
3
4
5
6
7
8
9

# 散列的迭代
st = {1,2,3,4,5,6}
for i in st:
    print(i)

1
2
3
4
5
6

dc = {'name': 'LiGuangZhu', 'age': 18}
# 字典key的迭代
for key in dc:
    print(key)

name
age

# 字典值的迭代
for key in dc:
    print(dc[key])

LiGuangZhu
18

for value in dc.values():
    print(value)

LiGuangZhu
18

迭代器（iterator）

迭代器是一个可以记住遍历位置的对象。for 循环迭代本质上就是通过迭代器来实现的。

通过内建函数 iter 可以创建迭代器。

iter('abc')
<str_iterator at 0x7fdc6a017670>

不是所有的数据类型都可以创建迭代器，凡是能够创建迭代器的对象称为可迭代对象，反之是不可迭代对象

range 函数

内建函数 range 可以创建输出整数序列的迭代器。

range(start, stop,step)

range(i,j)生成 i,i+1,i+2,…,j-1,start 默认为 0，当给定 step 时，它指定增长不长。

# 输出0-9
for i in range(10):
    print(i)

0
1
2
3
4
5
6
7
8
9

# 输出1-10
for i in range(1,11):
    print(i)

1
2
3
4
5
6
7
8
9
10

# 输出-1--10
for i in range(-1,-11,-1):
    print(i)

-1
-2
-3
-4
-5
-6
-7
-8
-9
-10

for 循环经常和 range 函数配合用来指定循环次数。

3.3 循环控制关键字

循环有时候需要主动中断来提高程序执行效率。

ls = [60,59,78,80,56,55]
# ls中存放的是所有学生的成绩
# 要判断是否有同学不及格
for i in ls:
    if i < 60:
        print('有同学不及格')

有同学不及格
有同学不及格
有同学不及格

可以发现上面的案例中，其实第二个成绩就不及格了，但是程序继续循环下去，如果数据量小，效率差别不大，但数据量大时会影响程序的执行效率。在实际的代码编写中会有很多这种情况，这是就需要能够主动结束循环的能力。

break 关键字

python 中循环结构可以使用 break 跳出当前循环体，脱离该循环后代码继续执行。

for i in ls:
    if i >= 60:
        print('有同学及格')
        break

有同学及格

index = 0
while index < len(ls):
    if ls[index] >= 60:
        print('有同学及格')
        break

有同学及格

for i in range(1,4):
    for j in range(1,4):
        if i==2:
            break
        print(i,j)

1 1
1 2
1 3
3 1
3 2
3 3

continue 关键字

python 中循环结构还可以使用 continue 关键字用来跳出当次循环，继续执行下一次循环。

# 输出所有的偶数
for i in range(10):
    if i%2 == 0:
        continue
    print(i)

1
3
5
7
9

for i in range(10):
    if i%2 == 0:
        break
    print(i)

else 关键字

循环结构还可以通过和 else 关键字进行配合，用来检测循环是否正常循环结束，还是 break 掉了。

for i in range(10):
    if i%2 != 0:
        continue
    print(i)
else:
    print('循环正常结束')

0
2
4
6
8
循环正常结束

for i in range(10):
    if i%2 != 0:
        break
    print(i)
else:
    print('循环正常结束')

二、异常处理

在程序的编写过程中会出现各种错误，语法错误在程序启动时就会检测出来，它是程序正常运行的前提条件。程序中还有一种错误发生在程序运行后，可能是由于逻辑问题，又或者是业务发生了改变，为了能让用户有更好的体验，加强代码的健壮性，我们需要对这些错误进行处理，也叫异常处理。

在 python 中通过 try-except 语句进行异常处理。

回忆我们前面关于成绩评价的案例，当用户输入非数值时程序会发生什么？

score = input('请输入你的成绩>>>:')
# 转换类型
score = float(score)
# 判断
if score < 40:
    print('等级：E')
elif 40<= score < 60:
    print('等级：D')
elif 60<= score < 75:
    print('等级：C')
elif 75<= score < 85:
    print('等级：B')
else:
    print('等级：A')

请输入你的成绩 >>>:abc

ValueError Traceback (most recent call last)

in
1 score = input(‘请输入你的成绩 >>>:’)
2 # 转换类型
----> 3 score = float(score)
4 # 判断
5 if score < 40:

ValueError: could not convert string to float: ‘abc’

在这里插入图片描述

try-except 语句的基本语法格式如下：

try:
	<语句块1>
except <异常类型1>:
	<语句块2>
except <异常类型2>:
    <语句块3>

语句块 1 中的代码如果发生异常，且异常与类型与对应 excep 语句中的异常类型相同则会被其捕获，从而执行对应的语句块

try:
    score = input('请输入你的成绩>>>:')
    # 转换类型
    score = float(score)
    # 判断
    if score < 40:
        print('等级：E')
    elif 40<= score < 60:
        print('等级：D')
    elif 60<= score < 75:
        print('等级：C')
    elif 75<= score < 85:
        print('等级：B')
    else:
        print('等级：A')
except ValueError as e:
    print(e)
    print('请输入正确的成绩')

请输入你的成绩 >>>:aaa
could not convert string to float: ‘aaa’
请输入正确的成绩

除了 try 和 except 关键字外，异常语句还可以与 else 和 finally 关键字配合使用，语法格式如下：

try: 
	<语句块1>
except <异常类型>:
	<语句块2>
...
else:
	<语句块3>
finally:
	<语句块4>

代码执行流程如下：
在这里插入图片描述

没有发生异常时，会执行 else 语句后的代码块，不管有没有发生异常，finally 语句后的代码块一定会执行

try:
    a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    index = input('请输入一个正整数>>>:')
    index = int(index)
    print(a[index])
except Exception as e:
    print(e)
    print('请输入一个正整数')
else:
    print('没有发生异常')
finally:
    print('我一定会执行')