06 Python流程控制

和其它编程语言一样，按照执行流程划分，Python 程序也可分为 3 大结构，即顺序结构、选择（分支）结构和循环结构：

• 顺序结构就是让程序按照从头到尾的顺序依次执行每一条 Python 代码，不重复执行任何代码，也不跳过任何代码
• 选择结构也称分支结构，就是让程序“拐弯”，有选择性的执行代码；换句话说，可以跳过没用的代码，只执行有用的代码
• 循环结构就是让程序“杀个回马枪”，不断地重复执行同一段代码

一、 分支结构

1.1 什么是分支结构

分支结构就是根据条件判断的真假去执行不同分支对应的子代码

1.2 为什么要用分支结构

人类某些时候需要根据条件来决定做什么事情，比如：如果今天下雨，就带伞

所以程序中必须有相应的机制来控制计算机具备人的这种判断能力

1.3 如何使用分支结构

Python 中的 if else 语句可以细分为三种形式

1. if 语句
2. if else 语句
3. if elif else 语句

# 1. if 语句
if 表达式：
	代码块
    
# 2. if else 语句
if 表达式：
	代码块1
else：
    代码块2
	
# 3. if elif else 语句
if 表达式1：
	代码块1
elif 表达式2：
	代码块2
elif 表达式3：
    代码块3
else：
    代码块n

以上三种形式中，第二种和第三种形式是相通的，如果第三种形式中的 elif 块不出现，就变成了第二种形式。另外，elif 和 else 都不能单独使用，必须和 if 一起出现，并且要正确配对

对语法格式的说明

• python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行

• “表达式”可以是一个单一的值或者变量，也可以是由运算符组成的复杂语句，形式不限，但执行结果必须为布尔类型

• 在if判断中所有的数据类型也都会自动转换成布尔类型,None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False,其余均为True

• “代码块”由具由相同缩进量的若干条语句组成

• if、elif、else 语句的最后都有冒号:，不要忘记

• 一旦某个表达式成立，Python 就会执行它后面对应的代码块；如果所有表达式都不成立，那就执行 else 后面的代码块；如果没有 else 部分，那就什么也不执行

• 不管有多少个分支，都只能执行一个分支，或者一个也不执行，不能同时执行多个分支

三目运算

条件为真时的结果 if 判段的条件 else 条件为假时的结果

三目运算符的嵌套

a if a>b else c if c>d else d
应该理解为
a if a>b else ( c if c>d else d )

1.4 if else对缩进的要求

1.4.1 不要忘记缩进

if、elif 和 else 后面的代码块一定要缩进，而且缩进量要大于 if、elif 和 else 本身

1.4.2 缩进多少合适

Python 要求代码块必须缩进，但是却没有要求缩进量，你可以缩进 n 个空格，也可以缩进 n 个 Tab 键的位置。但是从编程习惯的角度看，建议缩进 1 个 Tab 键的位置，或者缩进 4 个空格；它们两者其实是等价的，很多编辑器都可以将 Tab 键设置为 4 个空格

1.4.3 所有语句都要缩进

一个代码块的所有语句都要缩进，而且缩进量必须相同。如果某个语句忘记缩进了，Python 解释器并不一定会报错，但是程序的运行逻辑往往会有问题

1.4.4 同一代码块缩进量要相同

Python 虽然不限制代码块的缩进量，你可以随意缩进 n 个空格，但是，同一个代码块内的所有语句都必须拥有相同的缩进量，不能一会缩进 2 个空格，一会缩进 4 个空格

1.4.5 不要随便缩进

不需要使用代码块的地方千万不要缩进，一旦缩进就会产生一个代码块

1.5 if语句嵌套

if、if else 和 if elif else，这 3 种条件语句之间可以相互嵌套

# 在最简单的 if 语句中嵌套 if else 语句
if 表达式1：
    if 表示式2：
        代码块1
    else：
        代码块2
        
# 在 if else 语句中嵌套 if else 语句
if 表示式 1：
    if 表达式2：
        代码块1
    else：
        代码块2
else：
    if 表达式3：
        代码块3
    else：
        代码块4

if、if else 和 if elif else 之间可以相互嵌套。因此，在开发程序时，需要根据场景需要，选择合适的嵌套方案。需要注意的是，在相互嵌套时，一定要严格遵守不同级别代码块的缩进规范

除此之外，if分支结构中还可以嵌套循环结构，同样，循环结构中也可以嵌套分支结构

1.6 pass语句及其作用

在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节,有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现Python 提供了一种专业的做法，就是空语句 pass。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做

if 3>2:
    pass

1.7 assert断言函数及用法

assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误

assert 表达式

assert 语句的执行流程可以用 if 判断语句表示

if 表达式==True:
    程序继续执行
else:
    程序报 AssertionError 错误

明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃，这有利于我们对程序排错，提高程序的健壮性。因此，assert 语句通常用于检查用户的输入是否符合规定，还经常用作程序初期测试和调试过程中的辅助工具

assert 的检查是可以被关闭的，比如在命令行模式下运行 Python 程序时，加入 -O 选项就可以使程序中的 assert 失效。一旦 assert 失效，其包含的语句也就不会被执行

二、 循环结构

3.1 什么是循环结构

循环结构就是重复执行某段代码块

3.2 为什么要用循环结构

人类某些时候需要重复做某件事情

所以程序中必须有相应的机制来控制计算机具备人的这种循环做事的能力

3.3 如何使用循环结构

3.3.1 while循环语法

python中有while与for两种循环机制，其中while循环称之为条件循环

while 条件表达式：
    代码块

这里的代码块，指的是缩进格式相同的多行代码，不过在循环结构中，它又称为循环体

while 语句执行的具体流程为：首先判断条件表达式的值，其值为真（True）时，则执行代码块中的语句，当执行完毕后，再回过头来重新判断条件表达式的值是否为真，若仍为真，则继续重新执行代码块…如此循环，直到条件表达式的值为假（False），才终止循环

注意，在使用 while 循环时，一定要保证循环条件有变成假的时候，否则这个循环将成为一个死循环。所谓死循环，指的是无法结束循环的循环结构。纯计算无IO的死循环会导致致命的效率问题

解决无限（死）循环的方法只有一个，即确认循环结构中至少有一个位置能让循环条件为 False 或让 break 语句得以执行

3.3.2 for循环语法

循环结构的第二种实现方式是for循环，for循环可以做的事情while循环都可以实现，之所以用for循环是因为在循环取值（即遍历值）时for循环比while循环的使用更为简洁。

它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素

for 循环的语法格式

for 变量名 in 可迭代对象: # 此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解
    代码一
    代码二
    ...
#例1
for item in ['a','b','c']:
    print(item)
# 运行结果
a
b
c
# 参照例1来介绍for循环的运行步骤
# 步骤1：从列表['a','b','c']中读出第一个值赋值给item（item=‘a’），然后执行循环体代码
# 步骤2：从列表['a','b','c']中读出第二个值赋值给item（item=‘b’），然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽

3.4 循环结构中break用法

在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。但在某些场景，我们可能希望在循环结束前就强制结束循环，Python提供了 2 种强制离开当前循环体的办法

1. 使用 continue 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环
2. 只用 break 语句，可以完全终止当前循环

break 语句可以立即终止当前循环的执行，跳出当前所在的循环结构。无论是 while 循环还是 for 循环，只要执行 break 语句，就会直接结束当前正在执行的循环体。

这就好比在操场上跑步，原计划跑 10 圈，可是当跑到第 2 圈的时候，突然想起有急事要办，于是果断停止跑步并离开操场，这就相当于使用了 break 语句提前终止了循环

break 语句的语法非常简单，只需要在相应 while 或 for 语句中直接加入即可

break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下跳出循环体

username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        break # 用于结束本层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

循环嵌套+break

如果循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break

username = "jason"
password = "123"
count = 0
while count < 3:  # 第一层循环
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        while True:  # 第二层循环
            cmd = input('>>: ')
            if cmd == 'quit':
                break  # 用于结束本层循环，即第二层循环
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环，其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束

username = "jason"
password = "123"
count = 0

tag = True
while tag: 
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        while tag:  
            cmd = input('>>: ')
            if cmd == 'quit':
                tag = False  # tag变为False， 所有while循环的条件都变为False 
                break
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

3.5 循环结构中continue的用法

和 break 语句相比，continue 语句的作用则没有那么强大，它只会终止执行本次循环中剩下的代码，直接从下一次循环继续执行。

仍然以在操作跑步为例，原计划跑 10 圈，但当跑到 2 圈半的时候突然接到一个电话，此时停止了跑步，当挂断电话后，并没有继续跑剩下的半圈，而是直接从第 3 圈开始跑。

continue 语句的用法和 break 语句一样，只要 while 或 for 语句中的相应位置加入即可

# 打印1到10之间，除7以外的所有数字
number=11
while number>1:
    number -= 1
    if number==7:
        continue 
        # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
    print(number)

3.6 循环结构中else用法

无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，当 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束。

如果执行过程中被break，就不会执行else的语句

count = 0
while count <= 5 :
    count += 1
    print("Loop",count)
else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦   #没有被break打断，所以执行了该行代码
-----out of while loop ------

# 如果执行过程中被break，就不会执行else的语句
count = 0
while count <= 5 :
    count += 1
    if count == 3:
        break
    print("Loop",count)
else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句

3.7 循环嵌套及用法

Python不仅支持 if 语句相互嵌套，while 和 for 循环结构也支持嵌套。所谓嵌套（Nest），就是一条语句里面还有另一条语句，例如 for 里面还有 for，while 里面还有 while，甚至 while 中有 for 或者 for 中有 while 也都是允许的。

当 2 个（甚至多个）循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环，位于内层的循环结构常简称为内层循环或内循环。

循环嵌套结构的代码，Python 解释器执行的流程为：

1. 当外层循环条件为 True 时，则执行外层循环结构中的循环体；
2. 外层循环体中包含了普通程序和内循环，当内层循环的循环条件为 True 时会执行此循环中的循环体，直到内层循环条件为 False，跳出内循环；
3. 如果此时外层循环的条件仍为 True，则返回第 2 步，继续执行外层循环体，直到外层循环的循环条件为 False；
4. 当内层循环的循环条件为 False，且外层循环的循环条件也为 False，则整个嵌套循环才算执行完毕

嵌套循环执行的总次数 = 外循环执行次数 * 内循环执行次数

if 语句和循环（while、for）结构之间，也可以相互嵌套

i = 0
if i<10:
    for j in range(5):
        print("i=",i," j=",j) 

需要指明的是，上面程序演示的仅是 2 层嵌套结构，其实 if、while、for 之间完全支持多层（ ≥3 ）嵌套

if ...:
    while ...:
        for ...:
            if ...:
                ...

也就是说，只要场景需要，判断结构和循环结构之间完全可以相互嵌套，甚至可以多层嵌套