考点 7. 程序设计流程控制

📋 考纲要求

掌握顺序、条件（if/elif/else）、循环（for/while）三种控制结构的原理，能够写出正确的运行结果，并编写出简单的流程控制程序。

流程控制是指程序员通过特定的语法结构，改变程序代码的执行顺序，而非让代码单纯从上到下逐行执行。

流程控制让程序具备"判断""循环""分支选择"的能力，能根据不同的条件执行不同的逻辑，或重复执行某段代码，从而实现复杂的业务逻辑（比如登录验证、数据遍历、菜单选择等）。Python 有 3 种流程控制结构。

（1）顺序结构（默认）：代码从上到下逐行执行，是最基础的结构。
（2）分支结构（选择结构）：根据条件的判断结果，选择执行不同的代码块。
（3）循环结构：重复执行某段代码，直到满足终止条件。

一、顺序结构

顺序结构是 Python 程序默认的执行结构，是指代码从上到下、逐行依次执行，没有分支跳转、没有循环重复，是最简单、最基础的流程控制结构。

（1）核心特点：执行路径唯一，代码执行顺序与书写顺序完全一致。
（2）核心作用：完成无须判断、无须重复的基础操作，如变量定义、数据输入/输出、简单计算等。
（3）适用场景：简单的数值计算、单一的信息打印、变量赋值等基础任务。

1. 顺序结构流程图

顺序结构的处理流程如图 8-16 所示。

[图：图 8-16 顺序结构流程图，节点依次为：开始 → 处理操作1（如变量定义、计算）→ 输入/输出操作（如input/print）→ 处理操作2（如数据处理）→ 结束]

以下是几个典型的顺序结构代码示例。

【例 8.1】简单的数值计算。

python

# 第一步：定义变量（从上到下执行第一行）
a = 10
b = 20
# 第二步：计算（执行第二行后，执行此行）
sum_result = a + b
sub_result = a - b
# 第三步：输出结果（执行完计算后，执行此行）
print(f"{a} + {b} = {sum_result}")
print(f"{a} - {b} = {sub_result}")

运行结果：

python

10 + 20 = 30
10 - 20 = -10

执行顺序：定义 a→定义 b→计算 sum_result→计算 sub_result→打印第一个结果→打印第二个结果，严格按书写顺序执行。

【例 8.2】用户输入 + 简单处理。

python

# 第一步：提示用户输入（第一行执行）
name = input("请输入你的名字：")
age = int(input("请输入你的年龄："))
# 第二步：处理数据（输入完成后执行）
next_age = age + 1
# 第三步：输出结果（处理完成后执行）
print(f"你好，{name}! 你今年 {age} 岁，明年将是 {next_age} 岁。")

运行结果：

python

请输入你的名字：小明
请输入你的年龄：18
你好，小明！你今年 18 岁，明年将是 19 岁。

执行顺序：获取用户输入的名字→获取用户输入的年龄并转换为整数→计算明年的年龄→打印结果，一步接一步执行。

2. 顺序结构的注意事项

（1）执行不可逆：顺序结构中代码执行后无法回头，比如，先执行 a = 10，再执行 a = 20，最终 a 的值是 20，无法恢复到 10（除非重新赋值）。
（2）依赖关系：如果后一行代码依赖前一行的结果，那么前一行必须先执行，否则会报错。

python

# 错误写法：先使用变量，后定义
print(c)  # 执行此行时，c 未定义，直接报错 NameError
c = 30
# 正确写法：先定义，后使用（顺序执行）
c = 30
print(c)   # 输出：30

二、选择结构

Python 中的选择结构也叫分支结构，是指程序根据条件表达式的布尔结果（True/False），选择执行不同的代码块，而非单纯按顺序执行。

（1）核心作用：让程序具备"判断能力"，比如登录时验证密码是否正确、根据分数判断成绩等级、根据用户输入执行不同操作等。
（2）核心逻辑：先判断条件，再决定执行路径（单路径、双路径、多路径）。
（3）Python 语法基础：通过 if/if-else/if-elif-else 实现，依赖缩进划分代码块，冒号标记条件结束。

1. 选择结构的分类与语法详解

（1）单分支结构（if 语句）

①核心逻辑

仅在条件为 True 时执行指定代码块，条件为 False 时跳过，是最简单的选择结构。

②语法格式

python

if 条件表达式:
    代码块   # 缩进 4 个空格/1 个制表符，条件为 True 时执行

③标准流程图

单分支结构的处理流程如图 8-17 所示。

[图：图 8-17 单分支流程图，节点依次为：开始 → 条件表达式? → True 分支执行代码块 → 结束，False 分支直接到结束]

【例 8.3】判断是否成年。

python

age = 19
if age >= 18:
    print("你已成年，可独立办理银行卡")  # 条件为 True，执行此代码
print("程序结束")  # 无论条件是否成立，都会执行（非 if 代码块）

运行结果：

python

你已成年，可独立办理银行卡
程序结束

（2）双分支结构（if-else 语句）

①核心逻辑

条件为 True 时执行一个代码块，为 False 时执行另一个代码块，"二选一"必执行其一。

②语法格式

python

if 条件表达式:
    代码块 1   # 条件为 True 时执行 else
else:
    代码块 2   # 条件为 False 时执行

③标准流程图

双分支结构的处理流程如图 8-18 所示。

[图：图 8-18 双分支流程图，节点依次为：开始 → 条件表达式? → True 分支执行代码块1 → 结束，False 分支执行代码块2 → 结束]

【例 8.4】判断考试是否及格。

python

score = 58
if score >= 60:
    print("恭喜，考试及格！")
else:
    print("抱歉，考试不及格，需补考")

运行结果：

python

抱歉，考试不及格，需补考

（3）多分支结构（if-elif-else 语句）

①核心逻辑

处理多个条件判断，从上到下依次验证条件，匹配到第一个 True 的条件后执行对应代码块，剩余条件不再判断。若所有条件都为 False，则执行 else 代码块（else 可选）。

②语法格式

python

if 条件表达式 1:
    代码块 1
elif 条件表达式 2:
    代码块 2
elif 条件表达式 3:
    代码块 3
...  # 可添加多个 elif
else:
    代码块 n   # 所有条件都不满足时执行

③标准流程图

多分支结构的处理流程如图 8-19 所示。

[图：图 8-19 多分支流程图，节点依次为：开始 → 条件1? → True 分支执行代码块1 → 结束；False 分支 → 条件2? → True 分支执行代码块2 → 结束；False 分支 → 条件3? → True 分支执行代码块3 → 结束；False 分支 → 执行 else 代码块 → 结束]

【例 8.5】根据分数判断成绩等级。

python

score = 85
if score >= 90:
    print("成绩等级：优秀")
elif score >= 80:
    print("成绩等级：良好")   # 此条件匹配，执行后跳过后续判断
elif score >= 70:
    print("成绩等级：中等")
elif score >= 60:
    print("成绩等级：及格")
else:
    print("成绩等级：不及格")

运行结果：

python

成绩等级：良好

（4）嵌套选择结构

①核心逻辑

在一个选择结构的代码块中嵌套另一个选择结构，用于处理"多层条件判断"的场景，比如，先判断是否登录，再判断是否有权限。

②语法格式

python

if 外层条件:
    外层代码块 1
    if 内层条件:
        内层代码块 1
    else:
        内层代码块 2
else:
    外层代码块 2

③标准流程图

嵌套选择结构的处理流程如图 8-20 所示。

[图：图 8-20 嵌套选择结构流程图，节点依次为：开始 → 外层条件? → True 分支外层代码块1 → 内层条件? → True 分支内层代码块1 → 结束，False 分支内层代码块2 → 结束；外层条件? 的 False 分支执行外层代码块2 → 结束]

【例 8.6】判断是否能进入网吧（先判断年龄，再判断是否带身份证）。

python

age = 20
has_id = True
if age >= 18:
    print("年龄符合要求")
    if has_id:
        print("已携带身份证，可进入网吧")
    else:
        print("未携带身份证，无法进入")
else:
    print("年龄未满 18 岁，禁止进入")

运行结果：

python

年龄符合要求
已携带身份证，可进入网吧

2. 选择结构的关键注意事项

（1）条件表达式的类型

条件表达式可以是比较运算符（>=/<=/==/!=/>/<）、逻辑运算符（and/or/not）、直接的布尔值（True/False）、非布尔值（Python 会自动转换：0/空字符串/空列表为 False，非 0/非空为 True）。

python

num = 0
if num:    # 0 被转换为 False
    print("非零")
else:
    print("零")   # 输出：零

（2）缩进与冒号的必要性

①条件语句的结尾必须加冒号，否则会报语法错误。
②代码块必须缩进（4 个空格为规范），缩进不一致会报 IndentationError。
③同一代码块的缩进必须一致（不能混用空格和制表符）。

（3）多分支的"短路特性"

if-elif-else 中，只要匹配到一个 True 的条件，后续条件不再判断，因此条件顺序很重要。

python

# 错误顺序：先判断 >= 80，再判断 >= 90，会导致 >= 90 的情况被错误归类
score = 95
if score >= 80:
    print("良好")
elif score >= 90:
    print("优秀")    # 永远不会执行

（4）else 的可选性

else 不是必须的，若所有条件都为 False 且无 else，则选择结构无代码执行，直接跳过。

三、循环结构

Python 中的循环结构是指程序根据终止条件，重复执行某一段代码块（称为"循环体"），直到条件不满足时停止。

（1）核心作用

避免重复编写相同代码，提升程序效率和简洁性，如计算 1 到 100 的和、遍历列表所有元素、持续接收用户输入。

（2）核心要素

①循环体：需要重复执行的代码。
②终止条件：决定循环何时停止（若无终止条件，则会出现"死循环"）。
③循环类型：for 循环（遍历循环）、while 循环（条件循环），以及辅助控制循环的关键字（break/continue/else）。

1. for 循环

（1）核心逻辑

基于"可迭代对象"（列表、字符串、字典、range、文件等）的元素数量，依次遍历每个元素并执行循环体，循环次数由可迭代对象的元素个数决定。

（2）语法格式

python

for 变量 in 可迭代对象:
    循环体    # 缩进 4 个空格，每次遍历执行一次

（3）标准流程图

for 循环的处理流程如图 8-21 所示。

[图：图 8-21 for 循环流程图，节点依次为：开始 → 是否有下一个元素? → 是分支取出元素赋值给变量 → 执行循环体 → 回到是否有下一个元素?；否分支结束]

【例 8.7】统计字符串中字母 a 的个数。

python

text = "banana"
count = 0
for char in text:
    if char == 'a':
        count += 1
print(f"字母 a 的个数：{count}")

运行结果：

python

字母 a 的个数：3

【例 8.8】使用 range 生成数字序列。

【注】range(start, stop, step)：生成整数序列，start 默认为 0，stop 是结束值（不包含），step 默认为 1。

python

# 场景 1：遍历 1 到 10（不包含 10）
for i in range(1,10):
    print(i,end="")  # 输出：1 2 3 4 5 6 7 8 9
# 场景 2：计算 1 到 100 的和
sum_num = 0
for i in range(1,101):
    sum_num += i
print(f"\n1 到 100 的和：{sum_num}")   # 输出：5050
# 场景 3：步长为 2（遍历偶数）
for i in range(0,10,2):
    print(i,end="")   # 输出：0 2 4 6 8

2. while 循环（条件循环）

（1）核心逻辑

先判断"条件表达式"的布尔结果，若为 True，则执行循环体；若为 False，则终止循环。循环次数由条件表达式何时变为 False 决定。

（2）语法格式

python

while 条件表达式:
    循环体    # 缩进 4 个空格，条件为 True 时执行

（3）标准流程图

while 循环的处理流程如图 8-22 所示。

[图：图 8-22 while 循环流程图，节点依次为：开始 → 条件表达式? → True 分支执行循环体 → 回到条件表达式?；False 分支结束]

【例 8.9】计算 1 到 100 的和。

python

sum_num = 0
i = 1
while i <= 100:
    sum_num += i
    i += 1   # 关键：更新变量，否则条件永远为 True（死循环）
print(f"1 到 100 的和：{sum_num}")

运行结果：

python

1 到 100 的和：5050

【例 8.10】控制台菜单，输入 q 退出。

python

while True:
    choice = input("请输入操作（1. 查询 2. 添加 q. 退出）：")
    if choice == "1":
        print("执行查询操作")
    elif choice == "2":
        print("执行添加操作")
    elif choice == "q":
        print("退出程序")
        break   # 终止循环
    else:
        print("输入无效，请重新输入")

3. 嵌套循环

（1）核心逻辑

在一个循环的循环体中嵌套另一个循环（for/while 可互相嵌套），外层循环执行一次，内层循环执行完整的一轮。

（2）语法格式（以 for 嵌套 for 为例）

python

for 外层变量 in 外层可迭代对象:
    外层循环体
    for 内层变量 in 内层可迭代对象:
        内层循环体

【例 8.11】打印九九乘法表。

python

for i in range(1,10):    # 外层循环：行数
    for j in range(1,i+1):    # 内层循环：每行的列数
        print(f"{j}×{i}={i*j}",end="\t")
    print()    # 换行

运行结果：

python

1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
...
1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81

4. 循环控制关键字

循环控制关键字（表 8-28）用于灵活调整循环的执行流程，是 Python 循环结构的重要补充。其核心包括 break、continue、else（循环专属），三者作用不同但都服务于循环的"精准控制"。

表 8-28 循环控制关键字

关键字	核心作用	适用场景
break	立即终止当前层级的循环，跳出循环体，后续循环代码不再执行	满足特定条件时提前结束循环
continue	跳过当前次循环的剩余代码，直接进入下一次循环的条件判断/元素遍历	跳过不符合条件的单次循环
else	仅当循环正常结束（未被 break 终止）时，执行 else 代码块	验证循环是否完整执行

（1）break（终止当前循环）

①核心逻辑

当循环中遇到 break 时，会立刻停止当前循环（无论循环是否执行完毕），直接跳出循环体，执行循环外的后续代码。

②语法格式

python

# for 循环中使用 break
for 变量 in 可迭代对象:
    代码语句 1
    if 终止条件:
        break   # 触发后直接终止循环
    代码语句 2   # 触发 break 后，此行不会执行
# while 循环中使用 break
while 条件表达式:
    代码语句 1
    if 终止条件:
        break
    代码语句 2

③标准流程图（以 for 循环为例）

含 break 语句的 for 循环的处理流程如图 8-23 所示。

[图：图 8-23 break 流程图，节点依次为：开始 → 是否有下一个元素? → 是分支取出元素赋值给变量 → 执行代码语句1 → 终止条件? → 是分支结束；否分支执行代码语句2 → 回到是否有下一个元素?；外层是否有下一个元素? 的否分支也直接结束]

【例 8.12】遍历 1~5，遇到 3 时终止循环。

python

for i in range(1,6):
    if i == 3:
        print(f"遇到{i}，终止循环")
        break
    print(f"当前数字：{i}")

运行结果：

python

当前数字：1
当前数字：2
遇到 3，终止循环

（2）continue（跳过当前次循环）

①核心逻辑

当循环中遇到 continue 时，会跳过本次循环剩余的所有代码，直接进入下一次循环的判断（for 循环遍历下一个元素，while 循环重新判断条件）。

②语法格式

python

# for 循环中使用 continue
for 变量 in 可迭代对象:
    代码语句 1
    if 跳过条件:
        continue    # 触发后跳过后续代码，进入下一次循环
    代码语句 2    # 触发 continue 后，此行不会执行
# while 循环中使用 continue
while 条件表达式:
    代码语句 1
    if 跳过条件:
        continue
    代码语句 2

③标准流程图（以 for 循环为例）

含 continue 语句的 for 循环的处理流程如图 8-24 所示。

[图：图 8-24 continue 流程图，节点依次为：开始 → 进入下一次元素判断 → 是否有下一个元素? → 是分支取出元素赋值给循环变量 → 执行代码语句1 → 满足跳过条件? → 是分支回到进入下一次元素判断；否分支执行代码语句2 → 回到进入下一次元素判断；是否有下一个元素? 的否分支结束]

【例 8.13】遍历 1~5，跳过数字 3。

python

for i in range(1,6):
    if i == 3:
        print(f"跳过数字{i}")
        continue
    print(f"当前数字：{i}")

运行结果：

python

当前数字：1
当前数字：2
跳过数字 3
当前数字：4
当前数字：5

（3）else（循环正常结束的补充执行）

①核心逻辑

else 代码块与循环绑定，仅当循环未被 break 终止（即"正常结束"）时才会执行。若循环被 break 终止，则 else 代码块不会执行。

②语法格式

python

# for 循环 + else
for 变量 in 可迭代对象:
    循环体 else:
    else 代码块    # 循环正常结束时执行
# while 循环 + else
while 条件表达式:
    循环体 else:
    else 代码块

③标准流程图（以 for 循环为例）

for-else 的处理流程如图 8-25 所示。

[图：图 8-25 for-else 流程图，节点依次为：开始 → 是否有下一个元素? → 是分支取出元素赋值给变量 → 执行循环体 → 触发 break? → 是分支结束；否分支回到是否有下一个元素?；是否有下一个元素? 的否分支执行 else 代码块 → 结束]

python

# 示例 1：循环正常结束（无 break），执行 else
for i in range(1,4):
    print(f"当前数字：{i}")
else:
    print("循环正常结束，执行 else 代码块")
# 执行结果：
# 当前数字：1
# 当前数字：2
# 当前数字：3
# 循环正常结束，执行 else 代码块
# 示例 2：循环被 break 终止，不执行 else
for i in range(1,4):
    if i == 2:
        break
    print(f"当前数字：{i}")
else:
    print("循环正常结束，执行 else 代码块")
# 执行结果：
# 当前数字：1

（4）关键注意事项

①作用域限制：break/continue 仅作用于当前层级的循环，嵌套循环中不会影响外层/内层循环。

python

# 示例：嵌套循环中 break 仅终止内层循环
for i in range(1,3):
    for j in range(1,4):
        if j == 2:
            break    # 仅终止内层循环
        print(f"i={i},j={j}")
# 执行结果：
# i=1,j=1
# i=2,j=1

②else 的易混淆点：循环的 else 与分支结构的 else 无关，仅与循环是否"正常结束"绑定，不要混淆使用场景。

5. 循环结构的关键注意事项

（1）避免死循环

while 循环必须确保条件最终变为 False（如通过 i+=1 更新变量），或通过 break 终止。

（2）for 循环与 while 循环的选择

已知循环次数（如遍历列表、固定次数的重复操作），优先用 for 循环。

未知循环次数（如持续接收用户输入，根据动态条件终止），优先用 while 循环。

（3）缩进与代码块

循环体必须缩进，缩进错误会报 IndentationError；同一循环体的缩进需一致（建议用 4 个空格，避免混用空格和制表符）。

（4）循环中的变量作用域

在循环内定义的变量，循环外仍可继续访问（Python 无块级作用域）。

python

for i in range(3):
    num = i
print(num)    # 输出：2（最后一次循环的值）