3. 流程控制

• Python 提供了两种基本流程控制结构
• 分支结构（实现根据条件来选择性地执行某段代码）
  • if
• 循环结构（实现根据循环条件重复执行某段代码）
  • while / for…in
• 控制循环
  • break / continue

顺序结构

• 如果没有控制流程，python 程序的语句是一个顺序执行流，从上向下依次执行每条语句

if 分支结构

• if 分支使用布尔表达式或布尔值（bool）作为条件分支条件来进行分支控制

• Python 的 if 语句由如下三种形式

# 第一种形式
if expression :
    statements...


# 第二种形式
if expression :
   statements...
else :
   statements...


# 第三种形式
if expression :
   statements...
elif expression :  // 可以有零条或多条 elif 语句
   statements...  
else:
   statement...

• 如果 if 条件为 ”真"，程序就会执行 if 条件后面的多条语句
• 否则就会依次判断 elif 条件，如果 elif 条件为 “真”，程序就会执行 elif 条件后面的多条语句
• 如果前面的条件都为 “假”，程序就会执行 else 后的代码块（如果有）====================================================================
• if expression:, elif expression:, else:, 后缩进的多行代码被成为代码块
• 一个代码块通常被当成一个整体来执行（除非在运行过程中遇到 return, break, continue 等关键字）因此这个代码块也被成为条件执行体

# Python 是一门很 独特 的语言，它的代码块是通过缩进来标记的（大部分语言都使用花括号或 end 作为代码块的标记）
#   - 具有相同缩进的多行代码属于同一个代码块
#   - 如果代码莫名奇妙地乱缩进，Python解释器会报错（Python不是格式自由的语言）

s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
    # 只有当 age 大于 20 时，下面整体缩进的代码块才会被执行
    # 整体缩进的语句是一个整体，要么一起执行，要么一起不执行
    print('年龄已经大于20岁了')
    print('20岁以上的人应该学会承担责任')
    

不要忘记缩进

• 代码块一定要缩进，否则就不是代码块
• if 条件后的条件执行体一定要缩进。只有缩进后的代码才能算条件执行体
• Python 通常建议缩进为 4 个空格

s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
print('20岁以上的人应该学会承担责任')
# 上面程序的 if 条件下面 print 语句位于同一条竖线上
# 这样在 if 条件下就没有受控制的代码块了

# 定义变量b，并为其赋值
b = 5
if b > 4:
    # 如果 b > 4,则执行下面的条件执行体，只有一行代码作为代码块
    print('b 大于 4')
else:
    # 否则，执行下面的条件执行体,只有一行代码作为代码块
    b -= 1
# 对于下面代码而言，它已经不再是条件执行体的一部分，因此总会执行
print('b 不大于4')

# 定义变量 c，并为其赋值
c = 5
if c > 4:
    # 如果 c > 4，则执行下面的条件执行体，只有 c-=1 一行代码为条件执行体
    c -= 1
# 下面一行是普通代码，不属于条件执行体
print("c大于4")
# 此处的 else 将没有 if 语句，依次编译出错
else:
    # 否则，执行下面的条件执行体，只有一行代码作为代码块
    print("c 不大于 4")
    

不要随意缩进

# 虽然 Python 语法允许代码块随意缩进 N 个空格，但同一个代码块内的代码必须保持相同的缩进
# 不能一会缩进2个空格，一会缩进4个空格

s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
    print('年龄已经大于20岁了')  # 缩进 4 个
     print('20岁以上的人应该学会承担责任...')  # 缩进 5 个(同一个代码块的代码应该缩进相同的空格)
    
# python 代码块种的所有语句必须保持相同的缩进，既不能多，也不能少
# 对于不需要使用代码块的地方，千万不要随意缩进，否则程序也会报错

不要遗忘冒号

# 冒号精确表示代码块的开始点
#   - 这个功能不仅在条件执行体中如此，后面的循环体，方法体，类体全都遵循该规则
#   - 如果程序遗忘了冒号，pyton解释器就无法识别代码块的开始点

s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20
    print('年龄已经大于20岁了')  # 缩进 4 个
    print('20岁以上的人应该学会承担责任...')

if 条件的类型

if 条件可以是任意类型，当下面值作为 bool 表达式时，会被解释器当作 False 处理
  - False（布尔值False）
  - None （空数值）
  - 0（数值0）
  - ""（空字符串）
  - ()（空元组）
  - []（空列表）
  - {}（空对象）

if 分支的错误处理

当使用 if else 语句进行流程控制时，一定不要忽略了 else 所带的隐含条件
使用 if else 语句时：
  - 一定要先处理包含范围更小的情形
  - 优先把包含范围小的条件放在前面处理

pass 语句（空语句）

# python 的 pass 语句就是空语句
# 有时候程序需要占个位，放一条语句，但又不希望这条语句做任何事情，此时就可通过pass语句来实现
# 使用 pass 语句，可以让程序更完整


s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
    print('年龄已经大于20岁了')  # 缩进 4 个
    print('20岁以上的人应该学会承担责任...')
elif age < 5:
    pass  # 占位，不做任何事情
else:
    pass  # 占位，不做任何事情

循环结构

循环语句可能包含如下 4 个部分
  - 初始化语句(init_statement)：一条或多条语句，用于完成一些初始化工作。（初始化语句在循环开始之前执行）
  - 循环条件(test_statement)：这是一个布尔值表达式，这个表达式能决定是否执行循环体
  - 循环体(body_statement)：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行
  - 迭代语句(iteration_statements): 这个部分在依次循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束
这 4 个部分只是一般分类，并不是每个循环中都非常清晰地分出这 4 个部分

while 循环

while 循环的语法格式:
[init_statement]
while test_experssion :
    body_statement
    [iteration_statement]


while 循环也可被当成分支语句使用
如果 test_expression 条件一开始就为假，则循环体部分将永远不会获得执行机会

count_i = 0  # 循环的初始化条件

while count_i < 10:  # 当 count_i 小于 10 时，执行循环体
    print('count_i: ', count_i)  # 循环体
    count_i += 1  # 迭代语句
print('循环结束')

while 循环遍历列表和元组

# 由于列表和元组的元素都是有索引的
# 程序可通过 while 循环，列表或元组的索引来遍历列表和元组中的所有元素

a_tuple = ('a', 'b', 'c', 'd')
i = 0  # 只有 i 小于 len(a_tuple) 继续执行循环体
while i < len(a_tuple):
    print(a_tuple[i])  # 根据 i 来访问元素索引
    i += 1  # 迭代语句

# while 循环也可以用于遍历列表

for in 循环

for-in 循环专门用于遍历范围，列表，元素和字典等可迭代对象包含的元素
语法格式:
for 变量 in 字符串|范围|集合等:
    statements

- for-in 循环中变量的值受 for-in 循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值
- for-in 循环可用于遍历任何可迭代对象（指该对象中包含一个__iter__方法，且该方法的返回值对象具有 next() 方法）

# for-in 循环可用于遍历范围

s_max = input("请输入您想计算的阶乘: ")
mx = int(s_max)
result = 1
for num in range(1, mx + 1):
    result *= num

print(result)

# for-in 循环的循环计数器赋值在语法上是允许的，但没有什么意义，而且非常容易导致错误
for i in range(1, 5):
    i = 20
    print('i: ', i)

for in 循环遍历列表和元组

# 在使用 for-in 循环遍历列表和元组
# 列表或元组有几个元素，for-in循环的循环体就执行几次
# 针对每个元素执行依次，循环计数器会依次被赋值为元素的值

a_tuple = ('a', 'b', 'c', 'd')
for ele in a_tuple:
    print('当前元素是: ', ele)

for in 循环遍历字典

字典包含如下三个方法
  - items(): 返回字典所有 key-value 对
  - keys():  返回字典所有 key
  - values(): 返回字典所有 value

my_dict = {'语文': 89, '数学': 92, '英语': 80}

# items返回的是字典中所有 key-value 组成的列表
# 列表元素都是的长度为 2 的元组
# 程序要声明两个变量来分别代表 key, value(也是序列解包的应用)
for key,value in my_dict.items():
    print(key, value)
print('=' * 90)


for key in my_dict.keys():
    print(key, my_dict[key])
print('=' * 90)


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

循环使用 else

python 的循环都可以定义 else 代码块
当循环条件为  False 时，程序会执行 else 代码块

count_i = 0
while count_i < 5:
    print('count_i 小于5: ', count_i)
    count_i += 1
else:  # 在循环结束之前，会先执行 else 代码块
    # else 代码块其实没有太大的价值（将 else 代码块的内容直接放在循环体之外即可）
    print('count_i 大于或等于5: ', count_i)
    

# for 循环同样可以使用 else 代码块
# for 循环把区间，元组或列表的所有元素遍历一次之后
# for 循环会执行 else 代码块，
# 在 else 代码块中，循环计数器的值依然等于最后一个元素的值

a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for ele in a_list:
    print('元素:', ele)
else:  # 访问循环计数器的值，依然等于最后一个元素的值
    print('else块:', ele)
    

嵌套循环

把一个循环放在另一个循环体内，就可以形成嵌套循环
  - 嵌套循环既可以是 for-in 循环，嵌套 while 循环
  - 也可以是 while 循环嵌套 do while循环···
  - 各种类型的循环都可以作为外层循环，各种类型的循环也都可以作为内层循环

当程序遇到嵌套循环时，如果外层循环的循环条件允许
则开始执行外层循环的循环体，而内层的循环体将被外层循环的循环体来执行
  - 只是内层循环需要反复执行自己的循环体而已
  - 当内层循环执行结束且外层循环的循环体也执行结束后，将再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体

for i in range(0, 5):  # 外层循环
    j = 0
    while j < 3:  # 内层循环
        print('i的值为 %d , j 的值为: %d' % (i, j))
        j += 1
        

for 表达式

for 表达式用于利用其他区间，元组，列表等可迭代对象创建新的列表
语法格式:
  [表达式 for 循环计数器 in 可迭代对象]

- 在 for 关键字之前定义一个表达式，该表达式通常会包含循环计数器
- for 表达式没有循环体，因此不需要冒号

a_range = range(10)
a_list = [x * x for x in a_range]  # 对 a_range 执行 for 表达式
print(a_list)  # a_list 包含 10 个元素

b_list = [x * x for x in a_range if x % 2 == 0]
print(b_list)

# 将 for 表达式的方括号改为圆括号
# for表达式将不再生成列表，而是生成一个生成器（generator），该生成器同样可以使用 for 循环迭代
# 这种 for 表达式也被成为生成器推导式

c_generator = (x * x for x in a_range if x % 2 == 0)
# 使用 for 循环迭代生成器
for i in c_generator:
    print(i, end='\t')
    

# for 表达式可使用多个循环，就像嵌套循环一样
d_list = [(x, y) for x in range(5) for y in range(4)]  # d_list 列表包含 20 个元素
print(d_list)

常用工具函数

zip()

使用 zip() 函数可以把两个列表 "压缩" 成一个 zip 对象（可迭代对象）
  - 就可以使用一个循环进行变脸两个列表

# 如果使用 zip() 函数压缩 n 个列表，
# zip() 函数返回的可迭代对象的元素就是长度为 N 的元组
a = ['a', 'b', 'c']
b = [1, 2, 3]
print([x for x in zip(a, b)])
# [('a', 1), ('b', 2), ('c', 3)]

reversed() / sorted()

a = [20, 30, -1.2, 3.5, 90, 3.6]

# 有些时候，程序需要反向遍历，可通过 reversed() 函数
# reversed() 函数可接收各种序列（元组，列表，区间等）参数
#   - 返回一个"反序排列"的迭代器
#   - 该函数对参数本身不会产生任何影响
print([x for x in reversed(a)])


# sorted 可对可迭代对象按照由小到大的顺序进行遍历
print(sorted(a))

控制循环结构

break 结束循环

有些时候，需要在某种条件出现时强制终止循环，而不是等到循环条件为 False 时才退出循环
可以使用 break 来完成这个功能
break 用于完全结束一个循环，跳出循环体

for i in range(0, 10):
    print('i的值是: ', i)
    if i == 2:
        break  # 执行该语句时将结束整个循环
        

# 对于带 else 块的 for 循环，如果使用 break 强制终止循环，程序将不会执行 else 块
for i in range(0, 10):
    print('i的值是: ', i)
    if i == 2:
        break  # 执行该语句时将结束整个循环
    else:
        print('else: ', i)

# python 的 break 只可以结束其所在的循环，不可以结束嵌套循环的外层循环
exit_flag = False
for i in range(0, 5):
    for j in range(0, 3):
        print('i的值为:', i, ' j的值为:', j)
        if j == 1:
            exit_flag = True
            break  # 跳出内层循环
    if exit_flag:
        break  # 跳出外层循环
        

continue 跳过本次循环后的代码

···
continue 的功能和 break 有点类似，
区别是 continue 只是忽略当次循环剩下的语句，接着开始下一次循环
break 是完全终止循环本身
···

for i in range(0, 10):
    print('i的值是: ', i)
    if i == 1:
        continue  # 执行该语句时将结束整个循环
    print('continue后输出的语句: ')