保姆级入门系列阿ken教你学Python ——流程控制

Posted 2021-07-10 请叫我阿ken

你好，我是阿ken

许久未见

我又回来了

 

 

---

4.1 分支结构

Python 语言通过关键字if、elif 和 else 来构成分支结构，根据分支的数量，分支
结构分为单分支结构 if、二分支结构if-else和多分支结构 if-elif-else。

 

---

4.1.1 判断条件

判断条件是分支结构的核心，判断条件可以是具有布尔属性的任意元素，包括数据、变量或由变量与运算符组成的表达式，若其布尔属性为True，条件成立；若布尔属性为 False，条件不成立。
Python 中任意非零的数值、非空的数据类型的布尔属性为True，0 或空类型的布尔属性为 False。使用 bool() 函数查看目标的布尔属性，具体示例如下：

bool(80)
bool([])
bool('')
bool('Alpho')

除了非空常量外, Python 还常使用关系操作符和成员运算符构成判断条件,
关系运算符

分类	运算符	数学符号	操作符含义
关系运算符	==	=	等于
关系运算符	!=	≠	不等于
关系运算符	>	>	大于
关系运算符	<	<	小于
关系运算符	>=	≥	大于等于
关系运算符	<=	≤	小于等于
成员运算符	in	∈	存在
成员运算符	not in	不∈	不存在

使用上表中的部分运算符形成判断条件：

3>6
0 == Fa1se
5 != 0
3 in [1,2,3,4,5]
3 not in [1,2,3,4,5]

Python 支持通过保留字 not、and 和 or 对判断条件进行逻辑组合，这几个保留学
的功能如下：
(1) not，表示单个条件的 " 否 " 关系。如果 " 条件 " 的布尔属性为True,  " not条件 " 的布尔属性就为 False；如果 " 条件 " 的布尔属性为 Flase,  " not条件 " 的布尔属性就为 True。

 

(2) and，表示多个条件之间的 " 与 " 关系。当且仅当使用 and 连接的所有条件的布尔属性都为 True 时，逻辑表达式的布尔属性为True，否则为 Flase。
(3)or, 表示多个条件之间的 " 或 " 关系。当且仅当使用 or 连接的所有条件的布尔属性都是 False 时，逻辑表达式的布尔属性为 False，否则为 True。

使用以上保留字形成判断条件，具体示例如下：

not False
a = 3
(a > 5) or (a < 50 and a > 6)

 

---

4.1.2 单分支结构：if 语句

Python 单分支结构的语法格式如下：

if 判断条件：
代码段

以上格式中的 if、"." 和代码段前的缩进都是语法的一部分：if 关键字与判断条件构成 if 语句，if 语句后使用 " : " 结尾，代码段与 if 语句之间通过缩进形成逻辑关联。
若 if 语句中的判断条件成立，执行 if 语句后的代码段；若判断条件不成立，则跳过 if 语句后的代码段。单分支结构中的代码段只有 " 执行 " 与 " 跳过 " 两种情况。

使用单分支结构实现判断当天是否为工作日的程序：用户根据提示输入数字 1 ~7，程序根据输入进行判断，若输入为 1 ~ 5，则判定当天是工作日；若输入为 6、7，则判定当天不是工作日。完整代码如下：

#04_working day_if.py
day = int(input("今天是工作日吗 ( 请输入整数 1 ~ 7 ) ? "))
if day in [1,2,3,4,5]:
print("今天是工作日.")
if day in [6,7]:
print("今天非工作日。")

 

---

4.1.3  二分支结构：if-else 语句

事实上上述代码中无论这个程序的第1个 if 条件成立与否，第2个 if 结构总是会被执行，如此就出现了冗余。
为了避免执行不必要的条件结构，提高程序效率，Python 提供了二分支结构：if-else。
if-else 结构包含两个分支，这两个分支总是只有一个会被执行，该结构的语法格式如下：

if 判断条件:
代码段1
else:
代码段2

二分支结构中的 if、else、”:" 和代码段前的缩进都是语法的一部分。二分支结
构只有一个判断条件，根据判断条件的结果在两段代码中选择一段执行。

下面使用二分支结构优化：

day = int(input("今天是工作日吗 (请输入整数1-7)? "))
if day in [1,2,3,4,5]
print("今天是工作日。")
else:
print("今天非工作日。")

以上程序提示用户输入数宇1~7，并根据输入进行判断：若输入为1~5，判定当天是工作日；否则判定当天非工作日。

二分支结构中代码段只包含简单的表达式，该结构可浓缩为更简洁的表达方式，其语法格式如下：

表达式1 if 判断条件 else 表达式2

使用以上格式实现判断是否为工作日的程序,完整代码如下:
 

day = int(input("今天是工作日吗(请输入整数1~7)? "))
result = "是" if day in [1, 2, 3, 4, 5] else "非"
print("今天{}工作日。", .format(result) )

 

---

4.1.4 多分支结构：if-elif-else 语句

实际上上述代码改动后的程序出现了一个致命缺陷——程序逻辑存在问题：只要接收的输入不是
 1~5 ，程序总会判定 “ 今天非工作日。”
如此看来,上述代码中的第2个判断条件不应被省略，
Python 中提供了多分支结构：if-elif-else 。多分攴结构可连接多个判断条件，产生多个分支，但各个分支间存在互斥关系，最终至多有一个分支被执行。多分支结构的语法格式如下：

if判断条件1:
代码段1
elif 判断条件2:
代码段2
......
elif 判断条件n:
代码段n
else:
代码段 n+1

多分支结构中的 if、elif、else、":" 和代码段前的缩进都是语法的一部分，if 语句、每一个 elif 语句和 else 语句都是一个分支，其后的代码段通过缩进与其产生逻辑联系。进入多分支结构后先判断 if 语句中的条件，若满足则执行代码段1后跳出分支结构；若不满足则继续判断 elif 语句中的条件，在满足条件时执行相应代码段；若所有条件都不满足，执行 else 语句之后的代码段。

使用多分支结构实现判断当天是否为工作日的程序：

day = int(input("今天是工作日吗(请输入整数1~7)?"))
if day in[1, 2, 3, 4, 5]:
print("今天是工作日。")
elif day in [6,7];
print("今天非工作日。")
else:
print("输入有误。")

以上程序根据输入进行判断，若输入为1~5，判定当天是工作日；若输入为 7，判定当天非工作日；若输入为其他，提示“输入有误”。

多分支结构中条件较多，各分支为互斥关系，每个多分支结构中只有一段代码会被执行，但判断条件可能存在包含关系，此时需要注意判断条件的先后顺序。例如实现一个这样的程序：根据输入的百分制成绩输出由 A~E 表示的五分制成绩。此时很容易写出如下代码：

score = eval(input("请输入百分制成绩:") )
if score > 60.0:
grade = "D"
elif score > 70.0:
grade = "C"
elif score > 80.0:
grade = "B"
elif score > 90.0:
grade = "A"
else:
grade = "E"
print("对应的五分制成绩是:{}" .format(grade) )

以上程序依次将 60.0、70.0、80.0、90.0 作为成绩的临界点，若百分制成绩高于
60.0，五分制成绩为 D；若百分制成绩高于70.0，五分制成绩为C；以此类推。

执行以上程序，输入百分制成绩75：

请输入百分制成绩:75
对应的五分制成绩是:D

以上程序虽能正常运行，但运行结果却不符合预期，这显然是因为代码的逻辑存在问题。分析代码，我们会注意到高于70.0、80.0、90.0 的成绩必然高于60.0，因此只要输入的成绩高于60，程序总是执行条件之后的代码段，输出的五分制成绩总是D。修改代码，修正程序逻辑结构：

score=eval( input("请输入百分制考试成绩:"))
if score >90.0:
grade ="A
elif score >80.0:
grade
B
elif score >70.0:
grade
elif score >60.0:
grade ="D"
else
grade ="E"
print("对应的五分制成绩是:{}", format( grade))

以上程序通过调整判断条件的先后顺序修正了逻辑，当然也可以修改判断条件，使用更严格的条件来修正程序：

score = eval(input("请输入百分制考试成绩:") )
if score > 60.0 and score <= 70.0:
grade = "D"
elif score > 70.0 and score <= 80.0:
grade = "C"
elif score > 80.0 and score <= 90.0:
grade = "B"
elif score > 90.0 and score <= 100.0:
grade = "A"
else
grade = "E"
print("对应的五分制成绩是:{}", .format(grade) )

综上可知，判断条件是分支结构的核心，条件决定程序的流向，当分支中的条件存在包含关系时，条件的先后顺序同样影响程序的逻辑，因此，在使用分支结构时应着重注意判断条件，程序编写完成后亦应进行测试，以保证程序能够实现预期的功能。

 

---

4.1.5  分支嵌套

虽然程序在接收用户输入时给出了友好提示 " 今天是工作日吗(请输入整数1-7)? "，但用户操作时难免不会输入除 1~7 之外的数据。实际开发中开发人员通常会设置在开始逻辑判断之前、先检查用户输入，以判断输人是否符合预期。此时将会用到分支嵌套。
分支结构的内部可以包含分支结构，此种情况称为分支嵌套。分支嵌套的语法格式如下：

if 判断条件1:   # 外层单分支
[代码段1]
if 判断条件2:   # 内层单分支
代码段2
......
[代码段3]
......

以上语法格式中内层分支结构的语句与外层分支结构的代码段1 (代码段1可以为空) 有相同的缩进量，若外层语句判断条件1 的值为 True，执行代码段1，并对内层语句的判断条件2 进行判断，若判断条件2 的值为 True，则执行代码段2，否则跳出内层结构；若判断条件1 的值不满足，则既不执行代码段1，也不对内层语句的判断条件2 进行判断。

使用分支嵌套优化上述中的程序：
 

day = int(input(“今天是周几(请输入整数1-7)?"))
if day in [1, 2, 3, 4, 5, 6, 7]:
if day in [1, 2, 3, 4, 5]:
print("今天是工作日。")
else:
print("今天非工作日。")
else:
print("输入有误。")

 

以上代码先对用户输入的数据进行判断，限定内层分支结构只能对数字 1-7 行判断，否则提示 “ 输入有误。”。

下面使用分支嵌套实现这样一个程序：公司将在1月12日组织年会，用户根据提示输入月份，程序根据输入判断当月是否组织年会，若月份等于1则打印 " 这个月有年会活动 "，之后用户根据提示输入当天的日期，程序根据输入判断年会是否已经举办；若月份不等于1 则打印 " 这个月没有年会 "。完整代码如下：

 

month = int(input("请输入月份:")
if month == 1:  
print("这个月有年会活动。")
day = int(input("请输入日期:") )
if day == 12:
print("年会将在今天举行。")
elif day 12:
print("年会已经结束。")
elif day 12:
print("距离年会还有{}天", .format(12-day) )
else:
print("这个月没有年会。")

 

各种分支结构都可以嵌套使用，但过多的嵌套会导致程序逻辑混乱，降低程序的可读性，增加程序维护的难度，因此在进行程序开发时应仔细梳理程序逻辑，避免多层嵌套。                

 

---

4.2 循环结构

Python 程序中的循环结构分为 while 循环和 for 循环两种，其中 while 循环一般用于实现条件循环，for 循环一般用于实现遍历循环。

---

4.2.1 条件循环: while 循环

while 循环的语法格式如下：

while 循环条件:
代码段

当程序执行到 while 语句时，若循环条件为 True，执行之后的代码段，代码段执行完成后再次判断 while 语句中的循环条件，如此往复，直到循环条件为 False 时，终止循环，执行 while 循环结构之后的语句。

while 循环常用于循环计数，例如使用 while 循环实现计算n的阶乘，完整代码如下：

n = int(input("请输入一个整数:") )
fact = l
while i <= n:
fact = fact * i
i = i + 1
print( {} != {}" .format(n, fact) )

以上程序的循环结构通过条件 “ i <= n”  控制循环，通过语句 fact = fact * i 实现阶乘计算，通过语句 i = i + 1累加循环因子 i。当 i <= n 不成立时，n! 计算完毕，结束循环，打印阶乘计算结果。

Python 的 while循环也支持使用保留字 else产生分支：

while循环条件:
代码段1
else
代码段2

以上格式中 else 语句后的代码段2 只在循环正常执行结束后才会执行，因此一般代码段 2为循环执行情况的说明性语句。以实现计算 n的阶乘的程序为例，示例代码如下：
 

F14 factorial else. py
n=int( input("请输入一个整数:")
fact = 1
i = 1
print("n! 计算中...")
while i <= n:
fact = fact * i
i = i + 1
else:
print ("n!计算完成, 循环正常结束")
print ("{}!={}" .format(n, fact) )

 

执行以上:程序，输入整数4，执行结果如下：                                                     

请输入一个整数：4
n!计算开始
n!计算完成, 循环正常结束
n!=24

需要注意的是，若 while 循环的条件总是 True，循环将一直执行，这种情况被称为无限循环，也叫作死循环。
在实际开发中，有些程序不需要终止循环，比如游戏的主程序、操作系统中的监控程序等，但无限循环会占用大量内存，如无必要，程序中不应出现死循环，以免影响程序和系统的性能。

 

---

4.2.2 遍历循环：for 循环

遍历指逐一访问目标中的数据，例如逐个访问字符串中的字符；遍历循环指在循环中完成对目标的遍历。 Python 一般使用保留字 for 实现遍历循环，for 循环的语法格式具体如下：

for 循环变量 in 目标:
代码段

以上格式中的 " 目标 " 可以是字符串、文件、 range() 函数或后续章节中将会学习的组合数据类型等；" 循环变量 " 用于保存本次循环中访问到的遍历结构中的元素；
for 循环的循环次数取决于遍历结构中元素的个数。

 

1. 遍历字符串

使用 for 循环遍历字符串，并逐个打印字符串中的字符：                                                            

string = input("请输人一个字符串:")
for c in string:
print(c)

执行程序，输入字符串“ python”：
 

请输人一个字符串: python
p
y
t
h
o
n

    

2. for 循环与 range() 函数

range() 函数可创建一个整数列表，该函数的语法格式：

range([start, stop[,stop])

range() 函数中的参数说明：
(1) start：表示列表起始位置、该参数可以省略,此时列表默认从0开始。
(2) stop：表示列表结束位置，但不包括 stop。例如 range(5)、range(0,5) 表示列表 [0,1,2,3,4]。
(3) step：表示列表中元素的增幅，该参数可以省略，此时列表步长默认为1，例如 range(0, 5) 等价于 range(0, 5, 1)。
range() 函数一般与 for 循环搭配使用，以控制 for 循环中代码段的执行次数。使用 range() 函数搭配 for 循环，输出字符串中的每个元素：

string = input("请输入一个字符串:")
for i in range(len(string)):
print(string[i])

                                                                                                                                                 

多学一招：                                                                                                                          
与 while循环类似，for循环也能与保留字 else搭配使用。for-else 结构具体浯法格式如下：

for 循环变量 in 遍历结构:
代码段1
else:
代码段2

for-else 结构中，else 语句之后的代码同样只在循环正常执行之后才执行，因此代码段2中一般用于说明循环的执行情况。
 

---

 

4.2.3 循环控制

循环结构在条件满足时可一直执行，但在一些情况下，程序需要终止循环，跳出循环结构。例如在某些游戏正在运行时，按下ESC键，将终止程序主循环,结束游戏。
Python 语言中提供了两个保留字: break和 continue，以实现循环控制。

1. break

                                                                                                                                        
保留字 break用于跳出它所在的循环结构，该语句通常与 if 结构结合使用，具体语法格式如下：
 

while循环条件:
fox循环变量in遍历结构:
[代码段1]
if 判断条件:
break
代码段[2]
[代码段2]



for 循环变量 in 遍历结构：
[代码段1]
if 判断条件
break
[代码段2]

                                                                                                                                                      

修改程序，在 while循环结构中添加 break语句：                            

n = int(input("请输入一个整数:"))
fact = 1
i = 1
while i <= n:
fact = fact * i
i = i + 1
if i == 4:
break
print(" {}!={} " .format(n, fact))

以上程序在 while结构中添加了条件判断，当 i累加到 4时，程序将跳出循环，因此执行程序后，若输入的整数不小于3，计算结果总是等于 3的阶乘。                                                    

                                                                                                                                                    
修改程序，在 for循环中添加 break语句，具体示例如下：                                                         

string = input("请输入一个字符串:")
for c in string:
if c == "a":
break
print(c)

以上程序中若未设置 break语句，程序运行后根据提示输入字符串 " itcast "，for 循环将逐个打印 itcast 中的字符；但由于设置了 break语句，当遍历到字符 a时，程序跳出循环，最终只打印字符i、t、c。                                                                                                                                     

2. continue

保留字 continue 不会使程序跳出整个循环，但会使程序跳出本次循环，该保留字同样与 if语句结合使用，具体语法格式：                                                                                                                    
                                                                                                                                                        

while 循环条件:
[代码段1]
if 判断条件:
continue
[代码段2]

for 循环变量 in 遍历结构:
[代码段1]
if 判断条件:
continue
[代码段2]

使用 continue 替换程序中的 break：                                                                                               

string = input("请输人一个字符串:")
for c in string:
if c == "a":
continue
print(c)

以上程序在遍历到字符 a时会因 continue 语句而跳出本次循环，程序最终会打印除 a之外的字符。程序运行后在终端输入 itcast，运行结果如下:                                                                               

请输入一个字符串: itcast
i
t
c
s
t

                                                                                                                                                      
 

---

4.3 异常处理                                               

尽管程序开发人员在编写程序时会尽可能地考虑实际应用时出现的问题，但仍难避免因不规范操作导致的运行错误。例如程序中使用 eval() 函数处理与计算变量 num1 和 num2 接收的内容，理论上 num1 和 num2 应接收表示数值的字符串，然而用户的实际输入可能各式各样，此时程序将因错误而崩溃：                                                                                                                                      
 

num1 = itcast
num2 = 3
Traceback (most recent call last):
File "test.py", line 4, in<module>
sum = eval(num1) + eval(num2)
File "<string>", line l, in <module>
NameError: name 'itcast, is not defined

以上展示的由于输入与预期不匹配造成的错误有很多种可能，编写程序时很难逐一列举进行判断，为了保证程序能够稳定运行，编程语言一般都会提供异常处理语句，帮助程序捕获、控制与处理异常。                                                                                                                                             

Python 语言使用保留字 try和 except 组合成的分支结构以处理异常，此种分支结构的语法格式：

try:
代码段1
except:
代码段2

以上语法格式中的代码段1是需要捕获异常的语句，以及未出现异常时程序将执行的语句；代码段2 是出现异常时程序将会执行的语句。下面修改程序在其中添加异常处理结构：                            
 

try:
numl = input("num1=")
mum2 = input("num2=")
sum eval(num1) + eval(num2)
differ = eval(num1) - eval(num2)
print("sum=%d, differ=%d"%(sum, differ))
except:
print("程序异常退出。")

以上程序执行后若出现错误，将会执行第9行代码，打印 " 程序异常退出。"。程序执行后分别输入 123 和 test，执行结果具体如下所示:                                                                                              

num1 = 123
num2 = test
程序异常退出。

异常处理结构可以处理程序中出现的多种异常，包括输入异常、运行异常等。合理利用异常处理结构，有助于提高程序的稳定性。                                                                                                        
 

---

随机数模块—random

random 模块是 Python 内置的标准模块，在程序中导入该模块，可利用模块中的函数生成随机数据。                                                                                                                                                          

random 模块中的常用函数

函数	功能说明
random.random(a, b)	用于生成一个随机浮点数n, 0≤n<1.0
random.uniform(a, b)	用于生成一个指定范围内的随机浮点数n, 若a<b, 则a≤n≤b; 若a>b, 则b≤n≤a
random.randint(a, b)	用于生成一个指定范围内的整数n,a≤n≤b
random.randrange([start,] stop[,step])	生成一个按指定基数递增的序列,再从该序列中获取一个随机数
random.choice(sequence)	从序列中获取一个随机元素,参数 sequence表示一个序列类型
random.shuffle(x, [random])	将列表 x 中的元素随机排列
random.sample(sequence, k)	从指定序列中随机获取指定长度的片段并随机排列

---

4.4 本文回顾

主要讲解了程序分支结构以及循环结构，分支结构中主要介绍程序的单分支结构二分支结构和多分支结构以及分支嵌套方法；循环结构中主要介绍条件循环、遍历循环以及如何通过保留字 break、continue 跳出循环。另外简单介绍了程序的异常处理方法。         

 

          慢慢成长

          慢慢生活

          没有见过真正优秀的事物

          就很容易误把凤凰看作鸡

          可能一直攀登才是真理