Python从入门到实战（三）：流程控制与循环语句

一、程序为什么需要流程控制

[1. 程序默认执行流程](#1. 程序默认执行流程)

[2. 顺序、分支、循环](#2. 顺序、分支、循环)

二、分支语句

[1. 分支语句的三种形态](#1. 分支语句的三种形态)

[1.1 单分支语句（if）](#1.1 单分支语句（if）)

[2.2 双分支语句（if...else）](#2.2 双分支语句（if...else）)

[3.3 多分支语句（if...elif...else）](#3.3 多分支语句（if...elif...else）)

[2. 嵌套分支与代码优化](#2. 嵌套分支与代码优化)

[3. 分支结构案例：闰年判断](#3. 分支结构案例：闰年判断)

[四、while 循环](#四、while 循环)

[1. while 循环的语法与底层执行流程](#1. while 循环的语法与底层执行流程)

[2. 死循环](#2. 死循环)

[3. while 循环实战案例](#3. while 循环实战案例)

[五、for 循环](#五、for 循环)

[1. for 循环与可迭代对象](#1. for 循环与可迭代对象)

[2. range() 函数详解](#2. range() 函数详解)

[3. for 循环与 while 循环](#3. for 循环与 while 循环)

六、循环控制语句

[1. 跳转控制：break 与 continue](#1. 跳转控制：break 与 continue)

[2. 对比 break 与 continue](#2. 对比 break 与 continue)

[3. 实际案例](#3. 实际案例)

七、嵌套循环

[1. 嵌套循环的结构](#1. 嵌套循环的结构)

[2. 经典案例](#2. 经典案例)

[2.1 九九乘法表](#2.1 九九乘法表)

[2.2 二维坐标遍历](#2.2 二维坐标遍历)

八、综合案例

[1. 猜数字游戏](#1. 猜数字游戏)

[2. 几何图形打印](#2. 几何图形打印)

总结

一、程序为什么需要流程控制

在学习如何编写复杂的业务逻辑之前，必须先理解计算机是如何执行代码的。结构化程序设计提出了三种基本控制结构，它们是构建所有复杂软件系统的基石

1. 程序默认执行流程

在默认情况下，Python 解释器会按照代码在源文件中的物理编写顺序，从上到下、从左到右 依次逐行执行。这种逐行不间断执行的模式被称为顺序结构

python 复制代码

# 顺序结构示例
x = 10
y = 20
result = x + y
print(result)  # 严格按照1、2、3、4行的顺序执行

顺序结构适合处理线性、无分支的简单计算任务。然而，现实世界中的业务逻辑往往包含大量的条件选择（如：若用户未登录则跳转，已登录则放行）或重复操作（如：批量发送1万封邮件）。单凭顺序结构无法满足这些复杂的场景需求

什么是流程控制

流程控制是指通过特定的语法结构，在程序运行时有目的地改变代码的执行顺序

引入流程控制的目的，是为了打破单一的顺序结构，赋予程序 "逻辑判断" **与 "**重复执行" 的能力。通过流程控制，程序可以根据运行时的实时数据状态，自主决定哪些代码应该执行，哪些代码应该跳过，或者某些代码需要重复执行多少次

2. 顺序、分支、循环

无论是简单的脚本还是大型的分布式系统，其核心控制逻辑都可以拆解为以下三种基本结构的组合：

顺序结构：程序的核心主干，代码按书写顺序依次向下执行
分支结构：又称选择结构。程序根据给定的条件进行判断，条件成立时执行某一分支的代码，条件不成立时执行另一分支的代码（即 "二选一" 或 "多选一"）
循环结构：程序根据给定的条件，重复执行某一段代码。只要条件持续满足，该段代码就会不断运行，直到条件不再满足时才退出循环

二、分支语句

分支结构允许程序根据运行时特定的条件来选择性地执行不同的代码块。Python 中主要通过 if、elif 和 else 三个关键字来实现这一机制

1. 分支语句的三种形态

1.1 单分支语句（if）

单分支语句是选择结构最基础的形式。当指定的条件表达式评估为 True 时，执行其下方缩进的代码块；若为 False，则直接跳过

sql 复制代码

score = 90
if score >= 60:
    print("成绩合格")  # 只有条件满足时执行

Python 的缩进语法 ：与许多使用花括号定义代码块的语言（如 C、Java）不同，Python 严格使用强制缩进（通常为 4 个空格）来表示代码的层次与从属关系。缩进不一致会导致 IndentationError

2.2 双分支语句（if...else）

双分支语句用于处理 "非此即彼" 的场景。当条件满足时执行 if 块，不满足时则必然执行 else 块

python 复制代码

age = 16
if age >= 18:
    print("已成年")
else:
    print("未成年")

3.3 多分支语句（if...elif...else）

当需要评估的互斥条件超过两个时，应当使用多分支语句。程序会从上到下依次检测条件，一旦触发了某一个满足条件的判定块，执行完该块内部的代码后，整个多分支结构便会立即结束，后续的 elif 和 else 均不再进行判断

python 复制代码

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")  # 代码命中此处，执行后直接跳出整个分支结构
elif score >= 60:
    print("及格")
else:
    print("不及格")

2. 嵌套分支与代码优化

嵌套分支是指在一个分支语句的代码块内部，又包含了一个或多个完整的分支语句。它通常用于多层、递进式的条件筛选

python 复制代码

# 嵌套分支示例：进入复试阶段且成绩优秀
is_in_finals = True
score = 95

if is_in_finals:
    print("已进入复试阶段")
    if score >= 90:
        print("荣获优秀学员称号")
    else:
        print("通过复试")
else:
    print("未进入复试")

如何避免嵌套过深

在实际项目开发中，如果条件判断过于复杂，多层嵌套（通常超过 3 层）会导致代码向右剧烈延伸，形成所谓的 "箭头型代码"，严重破坏代码的可读性和可维护性

我们可以通过以下两种手段来优化过深的嵌套：

**使用逻辑运算符（and / or）：**如果多个条件具有逻辑上的关联性，可以通过逻辑运算符将其合并至同一层级
**引入 "卫语句" 思想：**卫语句的核心是将错误、异常或边界条件提前取反并退出（如使用 return 或跳出），从而让核心业务逻辑保持在最外层

python 复制代码

# 优化前：深度嵌套
if user.is_active:
    if user.has_permission:
        if token.is_valid:
            print("执行核心业务")

# 优化后：利用逻辑运算符扁平化
if user.is_active and user.has_permission and token.is_valid:
    print("执行核心业务")

3. 分支结构案例：闰年判断

为了融合本章知识，下面编写一个判断给定年份是否为闰年的程序。

判定规则：能被 4 整除但不能被 100 整除；或者能被 400 整除

python 复制代码

# 接收用户输入并转换为整型
year = int(input("请输入需要查询的年份："))

# 结合逻辑运算符的高效分支判定
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 年是闰年。")
else:
    print(f"{year} 年是平年。")

四、while 循环

在程序设计中，当需要重复执行某段代码时，如果机械地复制粘贴，不仅会导致代码极度臃肿，还会使后期的维护工作寸步难行。为此，编程语言引入了循环结构

while 循环是 Python 中最基本的循环控制结构之一，它属于条件控制循环，即循环的执行与终止完全取决于某个特定条件是否成立

1. while 循环的语法与底层执行流程

while 循环的基本语法结构非常简洁，类似于一个会重复执行的 if 语句：

python 复制代码

while 条件表达式:
    循环体（需要重复执行的代码块）

执行流程

程序运行到 while 语句时，首先判断后面的条件表达式
如果条件表达式的值为 True，程序将进入并执行其下方循环体代码
循环体执行完毕后，控制流会重新回到 while 的条件判定处，再次判断条件表达式
只要条件表达式持续为 True，上述过程就会不断重复；一旦结果为 False，循环立即终止，程序向下执行后续的结构

2. 死循环

在编写 while 循环时，开发者需要承担维护循环状态的责任。如果逻辑不当，很容易陷入死循环

死循环的成因

死循环是指循环的条件表达式恒为 True，导致控制流永远无法触发退出条件，程序将在该代码块中无限执行。常见的成因有两种：

缺少步进语句：忘记在循环体内修改控制循环条件的变量
条件判定逻辑错误：设定的条件在数学或逻辑上不可能变为 False

python 复制代码

# 典型错误示范：缺少步进，导致死循环
count = 1
while count <= 5:
    print(count)
    # 由于忘记书写 count += 1，count 永远为 1，循环将无限执行下去

死循环的应用场景

并非所有的死循环都是程序漏洞。在某些特定的工程开发场景中，我们主动需要构建一个死循环。例如：

操作系统底层的事件监听（等待用户点击鼠标）
Web 服务器持续监听网络端口，等待客户端的访问请求

在这些场景下，我们通常会配合后续会讲到的循环控制语句，在特定外部事件发生时强制跳出

3. while 循环实战案例

下面我们通过两个经典的计数与累加案例，来理解while 循环的实际应用

案例 A：1 到 100 的连续自然数累加

计算 1 + 2 + 3 + ... + 100 的最终和

python 复制代码

# 初始化累加器与计数器
total_sum = 0
i = 1

# 循环条件：计数器不超过 100
while i <= 100:
    total_sum += i  # 将当前计数值累加进结果
    i += 1          # 步进语句：计数器自增，确保循环能正常终止

print(f"1到100的累加结果为：{total_sum}")  # 输出：5050

案例 B：受控的用户输入验证

强制要求用户输入指定格式的内容，如果不符合要求则持续提示重新输入

python 复制代码

# 初始化变量
password = ""

# 只要密码不是 "123456"，循环就会一直拦截并重试
while password != "123456":
    password = input("请输入管理员密码以解锁系统：")

print("密码正确，系统已解锁。")

五、for 循环

与基于条件判断的 while 循环不同，Python 中的 for 循环是一种计数控制或遍历控制循环。它专注于在特定的序列或可迭代对象上进行循环，自动提取其中的每一个元素，直至元素被全部处理完毕

1. for 循环与可迭代对象

for 循环的基本语法形式极具可读性，非常接近自然语言的表达：

python 复制代码

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

什么是可迭代对象

在 Python 中，可迭代对象是指内部包含多个元素，且支持被逐一获取、遍历的容器。我们后续章节会详细学习的数据类型（如：字符串 str、列表 list、元组 tuple、字典 dict 等）全都是可迭代对象

当 for 循环执行时，它会自动从可迭代对象中取出第一个元素赋值给前面的变量，并执行一次循环体；随后自动获取第二个、第三个元素，直到可迭代对象内的所有元素被耗尽，循环便平稳退出

python 复制代码

# 示例：通过 for 循环直接遍历字符串中的每一个字符
text = "Python"
for char in text:
    print(char)  # 会依次分行打印 P、y、t、h、o、n

2. range() 函数详解

在实际开发中，如果我们不需要遍历具体的容器，而只是想让一段代码重复执行指定的次数（例如执行 10 次），通常会配合内置的 range 函数来生成数字序列

range() 函数在内存管理上表现得非常优秀。它并不会在内存中直接生成一个庞大的实体列表，而是返回一个延迟计算的生成器对象，只有在循环迭代到那一步时，才会动态生成对应的数字，这极大地节省了系统内存

根据传入参数的不同，range() 拥有以下三种常见格式：

单参数写法：range(stop)

含义：生成一个从 0 开始、到 stop 结束（且不包含 stop 自身）的连续整数序列
步长：默认为 1

python 复制代码

# 循环生成 0, 1, 2, 3, 4
for i in range(5):
    print(i, end=" ")  # 输出：0 1 2 3 4

双参数写法：range(start, stop)

含义：生成一个从 start 开始、到 stop 结束（且不包含 stop）的连续整数序列。
区间规则 ：遵循数学上的左闭右开区间 [start, stop)

python 复制代码

# 循环生成 2, 3, 4, 5, 6
for i in range(2, 7):
    print(i, end=" ")  # 输出：2 3 4 5 6

三参数写法：range(start, stop, step)

含义：生成一个从 start 开始、到 stop 结束（不含 stop）、且数值之间间隔为 step（步长）的整数序列
反向迭代：如果 step 为负数，则可以生成递减的倒序数字序列（此时 start 应大于 stop）

python 复制代码

# 正向步长，获取 10 以内的所有正奇数
for i in range(1, 10, 2):
    print(i, end=" ")  # 输出：1 3 5 7 9

# 负向步长，实现倒计时效果
for i in range(5, 0, -1):
    print(i, end=" ")  # 输出：5 4 3 2 1

3. for 循环与 while 循环

特性	while 循环	for 循环
循环类型	条件控制循环（由表达式真假控制）	计数/迭代控制循环（由遍历边界控制）
次数已知性	适合处理循环次数未知、依赖外部状态变化的场景	适合处理循环次数明确、或处理现成容器的场景
死循环风险	较高（若遗漏状态步进，极易导致死循环）	极低（随着序列元素耗尽，必定能安全退出）

六、循环控制语句

在程序执行循环的过程中，有时我们需要根据业务状态改变循环的执行。Python 提供了 break 和 continue 两个控制关键字，用于在循环内部实施跳转控制

1. 跳转控制：break 与 continue

break：终止当前循环

break 关键字用于立即终止当前所在的那一层循环。一旦在循环体中触发了 break ，程序将不再判断循环条件，也不再执行循环体中剩余的代码，而是直接跳出整个循环结构，向下执行循环之外的后续代码

python 复制代码

# break 示例：当计数器等于 3 时强行切断循环
for i in range(1, 6):
    if i == 3:
        print("触发 break，退出循环。")
        break
    print(f"当前数字：{i}")

continue：进入下一次循环

continue 关键字的作用是立即结束本次（当前这一轮）循环迭代。当程序遇到 continue 时，会跳过循环体中位于 continue 之后的所有剩余代码，直接开始全新一轮的循环

python 复制代码

# continue 示例：跳过数字 3 
for i in range(1, 6):
    if i == 3:
        continue  # 直接结束本轮，不再执行下方的 print
    print(f"当前数字：{i}")

2. 对比 break 与 continue

为了更清晰地理解这两个关键字在执行流和内存控制层面的区别，我们可以通过下表进行对比：

特性	break 关键字	continue 关键字
影响范围	终止整个循环结构的运行	仅终止当前单次迭代的运行
执行流	跳出循环体，走向整个循环底部的后续代码	回到循环头部，开始下一次条件判定或元素抓取
常见场景	找到目标数据后提前退出、死循环的受控中止	过滤不符合特定要求的无效数据（数据清洗）

3. 实际案例

下面我们通过一个带有次数限制的密码输入逻辑，来体会循环控制语句在真实业务中的协同应用

python 复制代码

# 设定初始状态
correct_password = "abc"
max_trials = 3

for trial in range(1, max_trials + 1):
    input_pwd = input(f"请输入银行卡密码（第 {trial} 次尝试）：")
    
    if input_pwd == correct_password:
        print("密码正确，正在登录系统...")
        break  # 验证成功，无需进行后续的尝试，彻底跳出循环
    
    # 如果密码错误，提示剩余次数
    remaining_trials = max_trials - trial
    if remaining_trials > 0:
        print(f"密码错误！您还剩 {remaining_trials} 次机会。")
    else:
        print("3次机会已耗尽，该银行卡已被冻结")

七、嵌套循环

在实际开发中，单层循环往往只能处理一维的线性数据。当面对多维数据（如多维列表）或复杂的组合逻辑时，需要在一个循环结构的内部再完整地嵌套另一个循环结构，这种模式被称为嵌套循环

1. 嵌套循环的结构

嵌套循环通常包含两层：外部的循环称为外层循环 ，内部的循环称为内层循环

执行流程

嵌套循环的联动机制可以概括为：外层循环每执行一步（循环一轮），内层循环都需要从头到尾完整地执行一遍（循环一整轮）

如果外层循环需要执行 M 次，内层循环需要执行 N 次，那么内层循环体中的核心代码总共将会被执行 M * N 次

python 复制代码

for i in range(1, 3):       # 外层循环执行 2 次
    print(f"--- 外层循环 i = {i} 开始 ---")
    for j in range(1, 4):   # 内层循环执行 3 次
        print(f"  内层循环 j = {j}")

注意：嵌套循环中的 break 行为

如果在内层循环中触发了 break 语句，它只能跳出当前所在的内层循环，而无法直接中断外层循环。外层循环依然会继续推进到下一个元素

2. 经典案例

2.1 九九乘法表

九九乘法表是理解嵌套循环行与列联动逻辑的经典案例。在输出时，外层循环控制乘法表的行数，内层循环控制每一行打印的列数

python 复制代码

# 外层循环控制行数（从 1 到 9）
for i in range(1, 10):
    # 内层循环控制每行的列数（列数 j 不能超过当前行数 i）
    for j in range(1, i + 1):
        print(f"{j}*{i}={i*j}", end="\t")
    
    # 当一整行的列公式全部打印完毕后，调用空的 print() 实现换行
    print()

输出示例：

2.2 二维坐标遍历

在处理图形学、游戏地图或者矩阵数据时，我们常常需要生成或遍历一个多维的坐标网格

python 复制代码

# 模拟遍历一个 3 行 4 列的二维像素矩阵
for row in range(1, 4):      # 控制行坐标 Y
    for col in range(1, 5):  # 控制列坐标 X
        print(f"({row}, {col})", end=" ")
    print()  # 换行

输出示例：

八、综合案例

通过前几章的学习，我们已经掌握了顺序、分支、循环以及循环控制语句的基本语法。为了将这些碎片化的知识点融会贯通，本章将通过两个经典的综合实战案例，演示如何在实际开发中构建具备复杂逻辑的程序

1. 猜数字游戏

业务描述

程序自动生成一个 1 到 100 之间的随机整数。用户共有 5 次猜测机会：

如果猜出的数字大于正确答案，提示 "太大了"；
如果猜出的数字小于正确答案，提示 "太小了"；
如果在规定次数内猜对，提示 "恭喜你，猜对了！" 并提前终止程序；
如果 5 次机会耗尽仍未猜对，则宣告游戏结束，并公布正确答案

要点分析

随机数生成：需要引入 Python 标准库中的 random 模块，并调用 random.randint(1, 100)
状态拦截与跳转：使用 while 或 for 循环控制猜测次数，结合 if...elif...else 进行大小判定，并在猜对时利用 break 强行跳出循环

代码实现

python 复制代码

import random

# 1. 初始化游戏数据：生成 1 到 100 的随机数，设置最大尝试次数
target_number = random.randint(1, 100)
max_chances = 5

# 2. 利用 for 循环控制猜测轮次
for current_round in range(1, max_chances + 1):
    # 接收输入并转换为整型
    guess = int(input(f"\n【第 {current_round} 次猜测】请输入你猜的数字："))
    
    # 3. 条件判定
    if guess == target_number:
        print(f"恭喜你！在第 {current_round} 轮就猜对了！答案正是 {target_number}。")
        break  
    elif guess > target_number:
        print("提示：太大了！")
    else:
        print("提示：太小了！")
        
    # 4. 次数耗尽提示机制
    remaining = max_chances - current_round
    if remaining > 0:
        print(f"你还剩 {remaining} 次机会。")
    else:
        print(f"\n游戏结束，正确答案是：{target_number}。")

2. 几何图形打印

下面我们分别实现直角三角形与等腰金字塔两个经典图形

靠左直角三角形

我们希望在控制台输出一个由五行组成的直角三角形，形态如下：

python 复制代码

*
**
***
****
*****

逻辑分析 ：总共有 5 行（外层循环控制行数 i）。仔细观察规律可以发现，第 i 行包含的星号 * 数量正好也是 i 个（内层循环控制打印星号的数量）

python 复制代码

# 直角三角形代码实现
rows = 5
for i in range(1, rows + 1):      # 外层循环控制行数 (1 到 5)
    for j in range(1, i + 1):     # 内层循环控制每行的星号数量 (1 到 i)
        print("*", end="")        # 连续打印星号，不换行
    print()                       # 整行打印完毕后触发换行

等腰金字塔

等腰金字塔的打印逻辑稍显复杂，每一行不仅需要控制星号的数量，还需控制星号左侧的空格数量

python 复制代码

    *
   ***
  *****
 *******
*********

逻辑分析：假设总行数为 N=5

对于第 i 行，其左侧的空格数量为 N - i 个（例如第 1 行有 4 个空格，第 2 行有 3 个空格）
对于第 i 行，其内部包含的星号数量为 2 * i - 1 个（例如第 1 行有 1 个，第 2 行有 3 个，第 3 行有 5 个）

因此，我们需要在外层循环内部，依次安排两个并列的内层循环：一个负责填充空格，另一个负责填充星号

python 复制代码

# 等腰金字塔代码实现
total_rows = 5

for i in range(1, total_rows + 1):
    # 内层循环一：控制打印左侧的空格数量
    for j in range(1, total_rows - i + 1):
        print(" ", end="")
        
    # 内层循环二：控制打印当前行的星号数量
    for k in range(1, 2 * i):
        print("*", end="")
        
    # 两种元素填充完毕后，执行换行
    print()

总结

本篇我们由浅入深地构建了 Python 程序的逻辑控制框架。我们首先理解了打破顺序执行流的必要性，并系统学习了分支语句（if...elif...else）在处理多路互斥条件时的底层截断运行机制，探究了如何利用逻辑运算符与卫语句思维避免深层的代码嵌套

随后，我们对比学习了两种截然不同的循环形态：基于条件控制、适合处理未知执行次数的 while 循环，以及基于计数与迭代控制、配合 range() 内存惰性序列的 for 循环。同时，我们剖析了 break 与 continue 对控制流重定向的区别。最后，通过嵌套循环在多维空间下的联动机制，我们成功实现了复杂控制台游戏的开发以及特定几何矩阵的动态输

流程控制赋予了程序处理复杂现实业务的决策能力。至此，你已经具备了编写具有独立交互、逻辑控制功能的完整脚本的能力。在下一篇教程中，我们将迈进 Python 进阶的核心门槛，探索组合数据类型（列表、元组、字典、集合）的存储与管理