python 零基础入门教程第 5 章. 程序流程控制 (一)

程序流程控制(一)

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

一、程序结构

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

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

1. 顺序结构

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

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

a = 1
a += 1
print(a)

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

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

从上往下依次执行

2. 分支结构

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

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

分支结构包括：

单分支
二分支
多分支

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

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': 'xinlan', 'age': 18}
# 字典key的迭代
for key in dc:
    print(key)

name
age

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

xinlan
18

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

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

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

测试派 Give testers a home.