python程序流程控制

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

一、程序结构

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

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

1. 顺序结构

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

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

a = 1
a += 1
print(a)

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

1. 定义变量 a，并赋值为整数 1
2. 变量 a 自加 1
3. 调用函数 print 输出变量 a 的值

从上往下依次执行

2. 分支结构

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

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

分支结构包括：

1. 单分支
2. 二分支
3. 多分支

2.1. 单分支

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

if <条件>：
    语句块

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

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

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

案例：成绩是否及格

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

2.4 分支嵌套结构

程序首先判断条件 1 是否为真

如果条件 1 为真，则判断条件 2 是否为真

• 条件 1 为真并且条件 2 为真，执行代码块 1
• 条件 1 为真并且条件 2 为假，执行代码块 2

如果条件 1 为假，则判断条件 3 是否为真

• 条件 1 为假并且条件 3 为真，执行代码块 3
• 条件 1 为假并且条件 3 为假，执行代码块 4

代码栗子

# 分支嵌套结构
from random import randint

res1 = randint(0, 1)
res2 = randint(0, 1)
if res1 == 0:
    if res2 != 0:
        print("0,1")
    else:
        print("0,0")
else:
    if res2 > 0:
        print("1,1")
    else:
        print("1,0")


# 输出结果
1,0

3. 循环结构

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

python 中循环结构有两种：

1. 条件循环也叫 while 循环
2. 遍历循环也叫 for 循环

3.1 条件循环

在循环结构中，程序的执行流程为：

1. 判断循环条件
2. 如果为真，则执行循环中的代码块；执行后跳转到步骤 1，重复第 1 步和第 2 步.
3. 如果为假，则循环结束

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

while + break 语句

• 在正常的循环中，当条件为假时，循环才会终止
• 有些情况下，希望能够提前从循环中退出，break 的作用就是这个

代码栗子

• 这是一个检测 number 是否会素数的循环
• factor 是因子，通过循环取 2 到 number - 1 的数字

number = 9
is_prime = True
factor = 2
while factor < number:
    print(factor)
    # 如果可以整除因子，证明不是素数
    if number % factor == 0:
        is_prime = False
        # 退出循环
        break
    # 循环自增
    factor = factor + 1
print(is_prime)


# 输出结果
False

while + continue 的栗子

• 在正常的循环中，循环块中的语句是顺序执行的
• 有些情况下，希望能够跳过循环块中的剩余语句，跳到下一次循环，就是 continue 的作用

# continue
sum = 0
number = 0
while number < 7:
    number += 1
    # 若是奇数则跳转到下一次循环
    if number % 2 != 0:
        continue
    sum += number

# 求和
print(sum)

2+4+6

while + else 的栗子

语法格式

while 条件：
    代码块 1
else:
    代码块 2

• 当循环条件为真时，执行代码块 1
• 当循环条件为假时，执行代码块 2

代码栗子一

# else
number = 1
while number <= 3:
    print(number)
    number = number + 1
else:
    print('At the end:', number)


# 输出结果
1
2
3
At the end: 4

代码栗子二

# else
number = 1
while number <= 5:
    print(number)
    number = number + 1
    if number == 3:
        # 提前结束循环
        break        
else:
    print('At the end:', number)


# 输出结果
1
2

因为提前结束了 while 循环，所以并不会到 else 里面

重点

• 若想执行 else 里面的代码块，必须是触达到循环条件且为假
• 如果在循环里面提前结束了循环（break），则不会执行 else 里面的代码块

3.2 遍历循环

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

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

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

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

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

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

遍历列表

# 遍历列表
lis = [1, 2, 3, 4]
for i in lis:
    print(l)


# 输出结果
1
2
3
4

遍历元组

# 遍历元组
tup = (1, 2, 3, 4)
for i in tup:
    print(i)


# 输出结果
1
2
3
4

遍历集合

# 遍历集合
se =set('abcdeg')
for i in se:
    print(i)

# 输出结果
b
g
d
c
e
a
# 对于序列而言，迭代按照顺序进行
# 对于集合而言，迭代是没有顺序的

遍历字典

# 遍历字典
dic = {1: 1, 2: 2, "3": 3, "4": 4}
for i in dic:
    print(i)


# 输出结果
1
2
3
4

迭代器（iterator）

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

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

  iter('abc')

<str_iterator at 0x7fdc6a017670>
不是所有的数据类型都可以创建迭代器，凡是能够创建迭代器的对象称为 可迭代对象，反之是 不可迭代对象
凡是可以通过for xx in xx 这种结构进行迭代的对象，就是可迭代对象。

range 函数

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

  range(start, stop,step)

• start: 计数从 start 开始。默认是从 0 开始
• stop: 计数到 stop 结束，但不包括 stop
• step：步长，默认为1

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 函数配合用来指定循环次数。

for i in range(3):

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('循环正常结束')

0

二、异常处理

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

在 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('我一定会执行')

请输入一个正整数 >>>:1
B
没有发生异常
我一定会执行