【Python基础】（三）Python 语法基础进阶：条件循环 + 实战案例，从入门到精通的核心跳板

---

目录

前言

一、先搞懂：程序执行的三种基本结构

[二、条件语句：让程序学会 "做选择"](#二、条件语句：让程序学会 “做选择”)

[2.1 条件语句的三种基本格式](#2.1 条件语句的三种基本格式)

[（1）单分支：if 语句（满足条件才执行）](#（1）单分支：if 语句（满足条件才执行）)

[（2）双分支：if-else 语句（二选一）](#（2）双分支：if-else 语句（二选一）)

[（3）多分支：if-elif-else 语句（多选一）](#（3）多分支：if-elif-else 语句（多选一）)

[2.2 核心重点：缩进与代码块](#2.2 核心重点：缩进与代码块)

（1）缩进的基本规则

（2）两个对比案例，看懂缩进的重要性

（3）嵌套代码块（缩进的进阶用法）

[（4）趣味梗："写 Python 需要自备游标卡尺"](#（4）趣味梗：“写 Python 需要自备游标卡尺”)

[2.3 实用技巧：空语句 pass 的用法](#2.3 实用技巧：空语句 pass 的用法)

[2.4 实战练习：3 个经典条件语句案例](#2.4 实战练习：3 个经典条件语句案例)

[练习 1：判断一个整数是正数、负数还是 0](#练习 1：判断一个整数是正数、负数还是 0)

[练习 2：判断年份是否为闰年](#练习 2：判断年份是否为闰年)

[练习 3：判断一个数是否为质数](#练习 3：判断一个数是否为质数)

[三、循环语句：让程序学会 "重复做"](#三、循环语句：让程序学会 “重复做”)

[3.1 while 循环："条件满足就一直做"](#3.1 while 循环：“条件满足就一直做”)

（1）基本语法格式

（2）核心注意点

[（3）经典示例：while 循环的 4 个常见用法](#（3）经典示例：while 循环的 4 个常见用法)

（4）无限循环与手动停止

[3.2 for 循环："遍历元素就做"](#3.2 for 循环：“遍历元素就做”)

（1）基本语法格式

（2）关键概念：可迭代对象

[（3）range () 函数：生成数字序列（for 循环的核心搭档）](#（3）range () 函数：生成数字序列（for 循环的核心搭档）)

[（4）经典示例：for 循环的 5 个常见用法](#（4）经典示例：for 循环的 5 个常见用法)

[（5）while 循环 vs for 循环：怎么选？](#（5）while 循环 vs for 循环：怎么选？)

[3.3 循环控制：break 和 continue 语句](#3.3 循环控制：break 和 continue 语句)

[（1）break 语句：结束整个循环](#（1）break 语句：结束整个循环)

[（2）continue 语句：跳过当前次循环，进入下一次](#（2）continue 语句：跳过当前次循环，进入下一次)

[（3）break 和 continue 的区别（关键！）](#（3）break 和 continue 的区别（关键！）)

[3.4 实战练习：3 个经典循环案例](#3.4 实战练习：3 个经典循环案例)

[练习 1：输入若干个数字，求平均值（用分号结束）](#练习 1：输入若干个数字，求平均值（用分号结束）)

[练习 2：打印 99 乘法表（嵌套 for 循环）](#练习 2：打印 99 乘法表（嵌套 for 循环）)

[练习 3：找出 100-200 之间的所有质数（for+break）](#练习 3：找出 100-200 之间的所有质数（for+break）)

[四、综合实战：手把手实现 "人生重开模拟器"](#四、综合实战：手把手实现 “人生重开模拟器”)

[4.1 游戏核心逻辑](#4.1 游戏核心逻辑)

[4.2 完整代码实现（含详细注释）](#4.2 完整代码实现（含详细注释）)

[4.3 核心解析](#4.3 核心解析)

[4.4 运行效果示例](#4.4 运行效果示例)

五、常见问题与避坑指南

[5.1 条件语句常见坑](#5.1 条件语句常见坑)

[5.2 循环语句常见坑](#5.2 循环语句常见坑)

[5.3 调试技巧](#5.3 调试技巧)

---

前言

如果说变量、数据类型是 Python 的 "砖瓦"，那么条件语句和循环语句就是搭建程序逻辑的 "钢筋骨架"。入门阶段，我们接触的 "顺序语句" 就像按部就班走直线 ------ 代码从上到下依次执行，没有任何分支和重复；但真正的编程场景往往充满 "选择" 和 "重复"：比如 "成绩≥90 分评优，否则评良""重复计算直到得到正确结果""按年龄阶段触发不同事件"。

掌握条件语句（if-elif-else）和循环语句（while/for），是从 "会写代码" 到 "会设计逻辑" 的关键跨越。本文将结合趣味案例、实战练习和避坑指南，全方位拆解 Python 流程控制核心语法，带你吃透 "选择逻辑" 和 "重复逻辑"，最后通过 "人生重开模拟器" 综合案例，让你融会贯通。无论你是编程新手，还是想巩固基础的学习者，这篇文章都能让你收获满满，废话不多说，直接开冲！

---

一、先搞懂：程序执行的三种基本结构

在正式学习前，我们先明确程序执行的三大核心结构 ------ 这是所有编程语言的基础逻辑，Python 也不例外：

1. 顺序结构：默认执行方式，代码从上到下依次执行，没有分支、没有重复（比如连续打印 3 行文字）；
2. 选择结构：也就是条件语句，根据不同条件执行不同代码块（比如 "满足 A 条件做 X，不满足做 Y"）；
3. 循环结构：也就是循环语句，重复执行某段代码直到条件不满足（比如 "重复打印 10 次'Hello'"）。

这三种结构组合起来，就能实现任何复杂的程序逻辑 ------ 就像搭积木，用简单的模块拼出复杂的造型。接下来，我们逐一拆解核心语法。

二、条件语句：让程序学会 "做选择"

生活中处处是选择："如果明天不下雨，就去爬山；否则宅家看书""如果考试得分≥90 是优秀，≥80 是良好，否则是合格"。条件语句就是把这种 "如果... 否则..." 的逻辑翻译成代码，让程序根据不同情况做出决策。

2.1 条件语句的三种基本格式

Python 中条件语句用**if"elif""else"**关键字实现，语法简洁且贴近自然语言，核心规则一定要记牢：

• 条件表达式后不用括号() ，结尾必须加冒号:；
• 条件成立后要执行的 "代码块"，用缩进 （推荐 4 个空格或 1 个 Tab）表示，而非大括号{}（这是 Python 的特色，也是新手容易踩坑的点）；
• 多条件分支用elif（else if 的缩写），而非单独写else if（比其他语言更简洁）。

（1）单分支：if 语句（满足条件才执行）

当只需要 "满足条件做某事，不满足就跳过" 时，用单分支 if 语句。语法格式：

if 条件表达式:
    代码块（条件为True时执行）
# 后续代码（无论条件是否成立，都会执行）

示例 1：判断是否成年

age = int(input("请输入你的年龄："))
if age >= 18:
    print("你已成年，可独立办理业务～")
print("查询结束！")  # 无论是否成年，都会执行

运行结果 1（输入 20）：

请输入你的年龄：20
你已成年，可独立办理业务～
查询结束！

运行结果 2（输入 16）：

请输入你的年龄：16
查询结束！

（2）双分支：if-else 语句（二选一）

当需要 "满足条件做 A，不满足做 B" 时，用if-else 双分支，覆盖所有可能性（非此即彼）。语法格式：

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

示例 2：判断数字奇偶性

num = int(input("请输入一个整数："))
if num % 2 == 0:  # %是取余运算符，偶数除以2余数为0
    print(f"{num} 是偶数")
else:
    print(f"{num} 是奇数")

运行结果（输入 15）：

请输入一个整数：15
15 是奇数

示例 3：判断是否认真学习

choice = input("输入 1 表示认真学习，输入 2 表示躺平摆烂：")
if choice == "1":
    print("你会找到好工作！")
else:
    print("你可能毕业就失业了！")

这个案例完美体现了双分支的核心：无论输入什么（只要是字符串类型），都会执行一个代码块，不会有 "遗漏"。

（3）多分支：if-elif-else 语句（多选一）

当需要判断多个条件（超过 2 种情况）时，用if-elif-else 多分支 ------ 按顺序判断条件，满足一个就执行对应代码块，后续不再判断（效率更高）；如果所有条件都不满足，执行 else 代码块。语法格式：

if 条件表达式1:
    代码块1（条件1为True时执行）
elif 条件表达式2:
    代码块2（条件1为False，条件2为True时执行）
elif 条件表达式3:
    代码块3（条件1、2为False，条件3为True时执行）
...
else:
    代码块N（所有条件都为False时执行）

示例 4：成绩等级评定

score = int(input("请输入你的考试成绩（0-100）："))
if score >= 90:
    print("等级：优秀")
elif score >= 80:
    print("等级：良好")
elif score >= 60:
    print("等级：合格")
else:
    print("等级：不合格")

运行结果（输入 85）：

请输入你的考试成绩（0-100）：85
等级：良好

注意 ：多分支的条件判断有顺序性！比如把score >= 60放在最前面，那么所有≥60 的成绩都会被判定为 "合格"，后面的条件永远不会执行。一定要按 "从严格到宽松" 或 "从高到低" 的顺序排列条件。

2.2 核心重点：缩进与代码块

Python 用缩进 表示代码块（一组要一起执行的代码），这是 Python 的特色，也是新手最容易踩坑的地方。很多编程语言用大括号{}包裹代码块，但 Python 强制要求缩进，目的是让代码更整洁、可读性更强。

（1）缩进的基本规则

• 同一代码块的缩进量必须一致（推荐 4 个空格，不要混合使用空格和 Tab）；
• 缩进级别不同，代码块的归属关系不同；
• 缩进错误会直接导致语法错误（IndentationError），程序无法运行。

（2）两个对比案例，看懂缩进的重要性

案例 A：print ("world") 在 if 代码块内

a = input("请输入一个整数：")
if a == "1":
    print("hello")
    print("world")  # 一级缩进，属于if代码块
print("python")  # 无缩进，属于全局代码块

运行结果（输入 1）：

请输入一个整数：1
hello
world
python

运行结果（输入 2）：

请输入一个整数：2
python

案例 B：print ("world") 在 if 代码块外

a = input("请输入一个整数：")
if a == "1":
    print("hello")  # 一级缩进，属于if代码块
print("world")  # 无缩进，属于全局代码块
print("python")  # 无缩进，属于全局代码块

运行结果（输入 2）：

请输入一个整数：2
world
python

两个案例的唯一区别是**print("world")**的缩进 ------ 缩进决定了代码是否属于 if 条件的执行范围。

（3）嵌套代码块（缩进的进阶用法）

代码块内部还可以嵌套另一个代码块（比如 if 里面套 if），此时需要用更深的缩进 表示层级关系。示例 5：嵌套条件判断（判断数字是否在 [10,20] 区间）

num = int(input("请输入一个整数："))
if num >= 10:
    print(f"{num} 大于等于10")
    if num <= 20:
        print(f"{num} 在 [10,20] 区间内")  # 二级缩进，属于内层if代码块
    else:
        print(f"{num} 大于20")  # 二级缩进，属于内层else代码块
else:
    print(f"{num} 小于10")  # 一级缩进，属于外层else代码块

运行结果（输入 15）：

请输入一个整数：15
15 大于等于10
15 在 [10,20] 区间内

（4）趣味梗："写 Python 需要自备游标卡尺"

如果嵌套的缩进层次太多，就容易分不清某个语句属于哪个层级，比如：

if a == 1:
    if b == 2:
        if c == 3:
            if d == 4:
                if e == 5:
                    print("hello")
    print("1")
print("2")

这里的print("1")属于if b == 2的代码块，**print("2")**属于全局代码块 ------ 但如果缩进层次再多，确实需要仔细核对，这也是 "写 Python 需要自备游标卡尺" 这个梗的由来。

避坑建议：

• 尽量避免超过 3 层的嵌套（嵌套太多会让代码可读性变差）；
• 用 IDE（比如 PyCharm）的自动缩进功能（按 Tab 键自动缩进 4 个空格）；
• 定期检查缩进，确保同一层级的代码缩进一致。

2.3 实用技巧：空语句 pass 的用法

有时候，我们可能需要 "占个位置" 来保持语法正确，但暂时不想执行任何操作 ------ 这时候就需要用到pass空语句。pass不会对程序执行有任何影响，只是一个**"占位符"**。

场景：比如先定义一个条件语句的框架，后续再补充代码。

a = int(input("请输入一个整数："))
if a == 1:
    print("hello")
elif a == 2:
    pass  # 暂时不执行任何操作，后续可以补充代码
else:
    print("输入有误")

如果没有 pass 会怎么样？ 如果写成下面这样，程序会直接报错（语法错误），因为**elif a == 2:**后面必须跟代码块（哪怕是空的）：

a = int(input("请输入一个整数："))
if a == 1:
    print("hello")
elif a == 2:  # 语法错误：缺少代码块
else:
    print("输入有误")

pass的核心作用：保持 Python 语法格式的完整性，避免因 "缺少代码块" 导致报错。

2.4 实战练习：3 个经典条件语句案例

练习 1：判断一个整数是正数、负数还是 0

a = int(input("请输入一个整数："))
if a > 0:
    print("正数")
elif a < 0:
    print("负数")
else:
    print("为 0")

运行结果（输入 - 5）：

请输入一个整数：-5
负数

练习 2：判断年份是否为闰年

闰年的判断规则：

1. 能被 400 整除的年份是闰年；
2. 能被 100 整除但不能被 400 整除的年份不是闰年；
3. 能被 4 整除但不能被 100 整除的年份是闰年；
4. 其他情况不是闰年。

实现代码（嵌套写法）：

year = int(input("请输入年份："))
if year % 100 == 0:
    # 世纪年（能被100整除），需判断是否能被400整除
    if year % 400 == 0:
        print(f"{year} 是闰年")
    else:
        print(f"{year} 是平年")
else:
    # 普通年（不能被100整除），判断是否能被4整除
    if year % 4 == 0:
        print(f"{year} 是闰年")
    else:
        print(f"{year} 是平年")

实现代码（简洁写法，用逻辑运算符）：

year = int(input("请输入年份："))
if (year % 100 != 0 and year % 4 == 0) or (year % 400 == 0):
    print(f"{year} 是闰年")
else:
    print(f"{year} 是平年")

运行结果（输入 2024）：

请输入年份：2024
2024 是闰年

练习 3：判断一个数是否为质数

质数的定义：大于 1 的整数，除了 1 和它本身，不能被其他整数整除。

num = int(input("请输入一个大于1的整数："))
is_prime = True  # 标记是否为质数，默认是True
if num == 2:
    print(f"{num} 是质数")
elif num % 2 == 0:
    print(f"{num} 不是质数")
else:
    # 遍历从3到num的平方根（优化：减少循环次数）
    for i in range(3, int(num**0.5) + 1, 2):
        if num % i == 0:
            is_prime = False
            break
    print(f"{num} 是质数" if is_prime else f"{num} 不是质数")

运行结果（输入 17）：

请输入一个大于1的整数：17
17 是质数

三、循环语句：让程序学会 "重复做"

生活中也有很多需要 "重复做" 的事情："每天早起打卡，坚持 30 天""计算 1 到 100 的和""重复接收用户输入，直到输入'退出'"。循环语句就是让程序重复执行某段代码，直到满足 "停止条件"。

Python 中有两种循环语句：while循环和for循环，它们各有适用场景，我们逐一拆解。

3.1 while 循环："条件满足就一直做"

while循环的核心逻辑：只要条件表达式为 True，就重复执行循环体；当条件表达式为 False 时，结束循环。

（1）基本语法格式

初始化语句（比如定义循环变量）
while 条件表达式:
    循环体（要重复执行的代码）
    更新语句（比如修改循环变量，避免无限循环）

（2）核心注意点

• 必须有 "更新语句"：如果循环变量不更新，条件会一直为 True，导致 "无限循环"（程序一直执行，无法停止，只能强制关闭）；
• 循环体必须缩进（和条件语句一样，用 4 个空格或 1 个 Tab）。

（3）经典示例：while 循环的 4 个常见用法

示例 1：打印 1-10 的整数

num = 1  # 初始化循环变量
while num <= 10:  # 循环条件：num≤10
    print(num)  # 循环体：打印num
    num += 1  # 更新语句：num加1（避免无限循环）

运行结果：

1
2
3
4
5
6
7
8
9
10

示例 2：计算 1-100 的和

sum_result = 0  # 初始化总和变量
num = 1  # 初始化循环变量
while num <= 100:
    sum_result += num  # 循环体：把num加到总和中
    num += 1  # 更新语句：num加1
print(f"1-100的和是：{sum_result}")

运行结果：

1-100的和是：5050

示例 3：计算 5 的阶乘（5! = 5×4×3×2×1）

result = 1  # 初始化结果变量（乘法的初始值是1，加法是0）
n = 1  # 初始化循环变量
while n <= 5:
    result *= n  # 循环体：result = result × n
    n += 1  # 更新语句：n加1
print(f"5的阶乘是：{result}")

运行结果：

5的阶乘是：120

示例 4：求 1! + 2! + 3! + 4! + 5!（阶乘和）

这个案例需要用到 "嵌套循环"（while 里面套 while）：

sum_factorial = 0  # 初始化阶乘和变量
num = 1  # 外层循环变量：控制计算哪个数的阶乘
while num <= 5:
    factorial = 1  # 初始化当前数的阶乘变量
    i = 1  # 内层循环变量：计算当前数的阶乘
    while i <= num:
        factorial *= i
        i += 1
    sum_factorial += factorial  # 把当前数的阶乘加到总和中
    num += 1  # 外层循环变量更新
print(f"1! + 2! + 3! + 4! + 5! = {sum_factorial}")

运行结果：

1! + 2! + 3! + 4! + 5! = 153

（4）无限循环与手动停止

如果不小心忘记写 "更新语句"，就会导致无限循环，比如：

num = 1
while num <= 10:
    print(num)  # 没有更新语句，num一直是1，条件永远为True

程序会一直打印 1，无法停止。解决方法：

• 强制关闭程序（比如在 PyCharm 中按 Ctrl+C）；
• 故意写无限循环，然后用break语句手动停止（后面会讲）。

3.2 for 循环："遍历元素就做"

for循环的核心逻辑：遍历 "可迭代对象" 中的每个元素，执行一次循环体；遍历完所有元素后，结束循环。

（1）基本语法格式

for 循环变量 in 可迭代对象:
    循环体（要重复执行的代码）

（2）关键概念：可迭代对象

"可迭代对象" 指的是 "内部包含多个元素，能一个一个把元素取出来的对象"，常见的有：

• **range()**函数生成的数字序列（最常用）；
• 字符串（遍历每个字符）；
• 列表、元组、字典等（后续会详细讲）。

（3）range () 函数：生成数字序列（for 循环的核心搭档）

**range()**函数专门用于生成一个整数序列，语法有 3 种形式：

1.range(end)：生成 0 到 end-1 的整数（左闭右开），步长为 1；

示例：range(5) → 0,1,2,3,4

2.range(start, end)：生成 start 到 end-1 的整数，步长为 1；

示例：range(1,6) → 1,2,3,4,5

3.range(start, end, step)：生成 start 到 end-1 的整数，步长为 step（step 可以是正数或负数）；

示例：range(2,11,2) → 2,4,6,8,10（步长为 2）

示例：range(10,0,-1) → 10,9,8,...,1（步长为 - 1，倒序）

（4）经典示例：for 循环的 5 个常见用法

示例 1：打印 1-10 的整数（用 range ()）

for i in range(1, 11):  # range(1,11)生成1-10的序列
    print(i)

运行结果和 while 循环一致，代码更简洁（不用手动初始化和更新循环变量）。

示例 2：打印 2,4,6,8,10（步长为 2）

for i in range(2, 12, 2):  # start=2, end=12（不包含12）, step=2
    print(i)

运行结果：

2
4
6
8
10

示例 3：打印 10-1（倒序，步长为 - 1）

for i in range(10, 0, -1):  # step=-1，从10递减到1
    print(i)

运行结果：

10
9
8
7
6
5
4
3
2
1

示例 4：计算 1-100 的和（for 循环版）

sum_result = 0
for i in range(1, 101):  # 生成1-100的序列
    sum_result += i
print(f"1-100的和是：{sum_result}")

运行结果：

1-100的和是：5050

示例 5：遍历字符串（遍历每个字符）

s = "Python"
for char in s:  # char是循环变量，依次取s中的每个字符
    print(char)

运行结果：

P
y
t
h
o
n

（5）while 循环 vs for 循环：怎么选？

循环类型	适用场景	优点	缺点
while 循环	1. 循环次数不确定（比如 "接收用户输入直到输入'退出'"）； 2. 基于条件重复（比如 "一直循环直到某个条件满足"）	灵活，能处理不确定次数的循环	需要手动初始化和更新循环变量，容易写无限循环
for 循环	1. 循环次数确定（比如 "打印 10 次"）； 2. 遍历可迭代对象（比如字符串、列表）	简洁，不用手动管理循环变量，不易出错	不适合处理 "条件型" 循环

总结 ：能用量化的for循环，就不用while循环；需要基于条件的 "不确定次数" 循环，再用while循环。

3.3 循环控制：break 和 continue 语句

有时候，我们需要在循环中 "提前停止循环" 或 "跳过当前次循环"------ 这时候就需要用到break和continue语句，它们是循环的 "调味剂"，让循环更灵活。

（1）break 语句：结束整个循环

break的作用：立即终止当前所在的循环，不管循环条件是否满足，直接跳出循环执行后续代码。

示例 1：模拟吃包子（吃到第 3 个有虫，直接停止）

for i in range(1, 6):
    if i == 3:
        print(f"第{i}个包子里有半只虫！不吃了！")
        break  # 结束整个for循环
    print(f"吃完第{i}个包子")

运行结果：

吃完第1个包子
吃完第2个包子
第3个包子里有半只虫！不吃了！

示例 2：无限循环 + break（手动停止）

while True:  # 无限循环（条件永远为True）
    num = input("请输入一个数字（输入'退出'停止）：")
    if num == "退出":
        print("程序停止！")
        break  # 手动停止循环
    num = float(num)
    print(f"你输入的数字是：{num}")

运行结果：

请输入一个数字（输入'退出'停止）：10
你输入的数字是：10.0
请输入一个数字（输入'退出'停止）：20
你输入的数字是：20.0
请输入一个数字（输入'退出'停止）：退出
程序停止！

（2）continue 语句：跳过当前次循环，进入下一次

continue的作用：立即跳过当前次循环的剩余代码，直接进入下一次循环（不会结束整个循环）。

示例 3：模拟吃包子（吃到第 3 个有虫，跳过这个，继续吃下一个）

for i in range(1, 6):
    if i == 3:
        print(f"第{i}个包子里有一只虫！跳过这个！")
        continue  # 跳过当前次循环，进入下一次（i=4）
    print(f"吃完第{i}个包子")

运行结果：

吃完第1个包子
吃完第2个包子
第3个包子里有一只虫！跳过这个！
吃完第4个包子
吃完第5个包子

（3）break 和 continue 的区别（关键！）

• break：结束整个循环（一刀两断，不再回头）；
• continue：跳过当前次循环（只是这一次不执行，下一次还会继续）。

用一张表总结：

语句	作用范围	后续操作
break	当前所在的循环	跳出循环，执行循环后的代码
continue	当前所在的循环	跳过当前次，进入下一次循环

3.4 实战练习：3 个经典循环案例

练习 1：输入若干个数字，求平均值（用分号结束）

需求：让用户反复输入数字，输入 ";" 时停止，计算所有输入数字的平均值。

sum_result = 0  # 总和
count = 0  # 数字个数
while True:
    num_str = input("请输入数字（输入';'结束）：")
    if num_str == ";":
        break  # 输入分号，停止循环
    # 判断输入是否为有效数字（避免报错）
    try:
        num = float(num_str)
        sum_result += num
        count += 1
    except:
        print("输入有误，请输入有效数字！")
if count == 0:
    print("没有输入有效数字，无法计算平均值！")
else:
    average = sum_result / count
    print(f"输入数字的平均值是：{average:.2f}")  # 保留2位小数

运行结果：

请输入数字（输入';'结束）：10
请输入数字（输入';'结束）：20
请输入数字（输入';'结束）：30
请输入数字（输入';'结束）：;
输入数字的平均值是：20.00

练习 2：打印 99 乘法表（嵌套 for 循环）

for i in range(1, 10):  # 外层循环：控制行数（1-9）
    for j in range(1, i+1):  # 内层循环：控制每行的列数（1-i）
        print(f"{j}×{i}={i*j}", end="\t")  # end="\t"：用制表符分隔，保持对齐
    print()  # 每行结束后换行

运行结果：

1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
...
1×9=9	2×9=18	...	9×9=81

练习 3：找出 100-200 之间的所有质数（for+break）

primes = []  # 存储找到的质数
for num in range(100, 201):
    is_prime = True
    # 优化：只需要判断到num的平方根
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            is_prime = False
            break  # 发现能整除，直接跳出内层循环
    if is_prime:
        primes.append(num)
print("100-200之间的质数：", primes)

运行结果：

100-200之间的质数： [101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]

四、综合实战：手把手实现 "人生重开模拟器"

学完条件语句和循环语句，我们来做一个趣味综合案例 ------"人生重开模拟器"。这是一款曾经很火的文字类小游戏，玩家设定初始属性后，会随机触发不同的人生事件，属性会随之变化，直到成年或触发特殊事件结束。

4.1 游戏核心逻辑

1. 设定初始属性：颜值（face）、体质（strong）、智力（iq）、家境（home），每个属性 1-10 分，总点数≤20；
2. 随机生成性别：掷骰子（1-6），单数为男孩，双数为女孩；
3. 随机生成出生点：根据家境分 4 个档位，每个档位触发不同的出生事件，属性会有增减；
4. 模拟人生经历：从 1 岁到 10 岁（幼年阶段），每年随机触发事件，根据性别、年龄、属性触发不同剧情，属性动态变化；
5. 特殊事件：比如重男轻女导致被遗弃，直接结束游戏。

4.2 完整代码实现（含详细注释）

import random
import sys
import time

# 游戏欢迎界面
print("=" * 50)
print("花有重开日，人无再少年")
print("欢迎来到------人生重开模拟器")
print("=" * 50)

# 第一步：设定初始属性（总点数≤20，每个属性1-10）
while True:
    print("\n请设定初始属性（可用总点数 20，每个属性1-10分）")
    try:
        face = int(input("设定 颜值(1-10)："))
        strong = int(input("设定 体质(1-10)："))
        iq = int(input("设定 智力(1-10)："))
        home = int(input("设定 家境(1-10)："))
        
        # 验证属性合法性
        if not (1 <= face <= 10 and 1 <= strong <= 10 and 1 <= iq <= 10 and 1 <= home <= 10):
            print("❌ 每个属性必须在1-10之间！请重新输入！")
            continue
        if face + strong + iq + home > 20:
            print(f"❌ 总点数为{face+strong+iq+home}，超过20点上限！请重新输入！")
            continue
        
        # 属性设定成功
        print("\n✅ 初始属性设定完成！")
        print(f"颜值：{face} | 体质：{strong} | 智力：{iq} | 家境：{home}")
        break
    except:
        print("❌ 输入有误！请输入1-10之间的整数！")

# 第二步：随机生成性别（掷骰子1-6，单数男孩，双数女孩）
print("\n🎲 正在随机生成性别...")
time.sleep(1)  # 暂停1秒，增加游戏体验
gender_point = random.randint(1, 6)
if gender_point % 2 == 1:
    gender = "boy"
    print("👦 你是个男孩！")
else:
    gender = "girl"
    print("👧 你是个女孩！")

# 第三步：根据家境生成出生点（4个档位，随机触发细分事件）
print("\n🎲 正在随机生成出生点...")
time.sleep(1)
birth_point = random.randint(1, 3)  # 掷骰子1-3，细分出生场景

if home == 10:
    # 第一档：家境满分（帝都高官政要）
    print("🏰 你出生在帝都，你的父母是高官政要！")
    home += 1  # 家境+1
    iq += 1    # 智力+1
    face += 1  # 颜值+1
elif 7 <= home <= 9:
    # 第二档：家境良好（大城市）
    if birth_point == 1:
        print("🏙️  你出生在大城市，你的父母是公务员！")
        face += 2  # 颜值+2
    elif birth_point == 2:
        print("🏙️  你出生在大城市，你的父母是大企业高管！")
        home += 2  # 家境+2
    else:
        print("🏙️  你出生在大城市，你的父母是大学教授！")
        iq += 2    # 智力+2
elif 4 <= home <= 6:
    # 第三档：家境普通（三线城市/镇上）
    if birth_point == 1:
        print("🏡 你出生在三线城市，你的父母是教师！")
        iq += 1  # 智力+1
    elif birth_point == 2:
        print("🏡 你出生在镇上，你的父母是医生！")
        strong += 1  # 体质+1
    else:
        print("🏡 你出生在镇上，你的父母是个体户！")
        home += 1  # 家境+1
else:
    # 第四档：家境较差（农村/穷乡僻壤）
    if birth_point <= 2:
        print("🌾 你出生在村里，你的父母是辛苦劳作的农民！")
        strong += 1  # 体质+1
        face -= 2    # 颜值-2
    elif birth_point == 3:
        print("🌧️  你出生在穷乡僻壤，你的父母是无业游民！")
        home -= 1    # 家境-1
    else:
        print("💔 你出生在镇上，你父母感情不和！")
        strong -= 1  # 体质-1

# 出生后属性更新
print(f"\n出生后属性更新：")
print(f"颜值：{face} | 体质：{strong} | 智力：{iq} | 家境：{home}")
time.sleep(2)  # 暂停2秒，让玩家看清属性

# 第四步：模拟幼年阶段（1-10岁）的人生经历
print("\n" + "=" * 50)
print("👶 幼年阶段（1-10岁）开始！")
print("=" * 50)

for age in range(1, 11):
    time.sleep(1.5)  # 每岁暂停1.5秒，模拟时间流逝
    info = f"\n📅 你今年 {age} 岁，"
    event_point = random.randint(1, 3)  # 掷骰子1-3，触发不同事件
    
    # 事件1：重男轻女（仅女孩，家境≤3，低概率触发）
    if gender == "girl" and home <= 3 and event_point == 1:
        info += "你家里人重男轻女思想非常严重，你被遗弃了！"
        print(info)
        print("💀 游戏结束！")
        sys.exit(0)  # 退出程序
    
    # 事件2：生病（体质<6，非高概率触发）
    elif strong < 6 and event_point != 3:
        info += "你生了一场病，"
        if home >= 5:
            info += "在父母的精心照料下恢复了健康！"
            strong += 1  # 体质+1
            home -= 1    # 家境-1（医疗开销）
        else:
            info += "你的父母没精力管你，你的身体状况更糟糕了！"
            strong -= 1  # 体质-1
    
    # 事件3：因颜值被孤立（颜值<4，年龄≥7）
    elif face < 4 and age >= 7:
        info += "你因为长得太丑，别的小朋友不喜欢你，"
        if iq > 5:
            info += "你决定用学习填充自己！"
            iq += 1  # 智力+1
        else:
            if gender == "boy":
                info += "你和别的小朋友经常打架！"
                iq -= 1    # 智力-1
                strong += 1  # 体质+1
            else:
                info += "你经常被别的小朋友欺负！"
                strong -= 1  # 体质-1
    
    # 事件4：智商较低（智力<5）
    elif iq < 5:
        info += "你看起来傻傻的，"
        if home >= 8 and age >= 6:
            info += "你的父母给你送到更好的学校学习！"
            iq += 1  # 智力+1
        elif 4 <= home <= 7:
            if gender == "boy":
                info += "你的父母鼓励你多运动，加强身体素质！"
                strong += 1  # 体质+1
            else:
                info += "你的父母鼓励你多打扮自己！"
                face += 1  # 颜值+1
        else:
            info += "你的父母为此经常吵架！"
            if event_point == 1:
                strong -= 1  # 体质-1
            elif event_point == 2:
                iq -= 1  # 智力-1
    
    # 事件5：健康成长（无特殊情况）
    else:
        info += "你健康成长，"
        if event_point == 1:
            info += "看起来更聪明了！"
            iq += 1  # 智力+1
        elif event_point == 2:
            info += "看起来更好看了！"
            face += 1  # 颜值+1
        else:
            info += "看起来更结实了！"
            strong += 1  # 体质+1
    
    # 打印当年经历和属性更新
    print(info)
    print(f"📊 当前属性：颜值={face} | 体质={strong} | 智力={iq} | 家境={home}")

# 幼年阶段结束
print("\n" + "=" * 50)
print("🎉 幼年阶段（1-10岁）结束！")
print("📊 最终属性：颜值={face} | 体质={strong} | 智力={iq} | 家境={home}")
print("💡 后续可扩展青年、壮年、老年阶段，敬请期待！")

4.3 核心解析

1. 条件语句的多层嵌套 ：用if-elif-else嵌套处理不同性别、家境、年龄的事件，覆盖所有可能场景；
2. 循环语句的灵活使用 ：用 for循环遍历 1-10 岁，模拟每年的人生经历，用 while 循环处理初始属性的输入验证；
3. 用户体验优化 ：加入**time.sleep()**暂停功能，让输出更有节奏感；添加中文提示和表情符号，更生动有趣；
4. 异常处理 ：用 try-except 捕获用户输入错误，避免程序崩溃；
5. 属性动态更新：每个事件都会影响属性，让游戏更有随机性和可玩性。

4.4 运行效果示例

==================================================
花有重开日，人无再少年
欢迎来到------人生重开模拟器
==================================================

请设定初始属性（可用总点数 20，每个属性1-10分）
设定 颜值(1-10)：6
设定 体质(1-10)：7
设定 智力(1-10)：5
设定 家境(1-10)：2

✅ 初始属性设定完成！
颜值：6 | 体质：7 | 智力：5 | 家境：2

🎲 正在随机生成性别...
👧 你是个女孩！

🎲 正在随机生成出生点...
🌾 你出生在村里，你的父母是辛苦劳作的农民！

出生后属性更新：
颜值：4 | 体质：8 | 智力：5 | 家境：2

==================================================
👶 幼年阶段（1-10岁）开始！
==================================================

📅 你今年 1 岁，你健康成长，看起来更聪明了！
📊 当前属性：颜值=4 | 体质=8 | 智力=6 | 家境=2

📅 你今年 2 岁，你健康成长，看起来更结实了！
📊 当前属性：颜值=4 | 体质=9 | 智力=6 | 家境=2

...（中间省略部分输出）

📅 你今年 10 岁，你健康成长，看起来更好看了！
📊 当前属性：颜值=7 | 体质=10 | 智力=8 | 家境=2

==================================================
🎉 幼年阶段（1-10岁）结束！
📊 最终属性：颜值=7 | 体质=10 | 智力=8 | 家境=2
💡 后续可扩展青年、壮年、老年阶段，敬请期待！

五、常见问题与避坑指南

5.1 条件语句常见坑

1. 忘记加冒号 ：if/elif/else 后面必须加冒号:，否则语法错误；
2. 缩进错误：同一代码块的缩进不一致，或忘记缩进，导致 IndentationError；
3. 多分支条件顺序错误：把宽松的条件放在前面，导致后面的条件永远不执行；
4. 用=代替== ：=是赋值，==是判断相等，比如if a = 1会报错。

5.2 循环语句常见坑

1. 无限循环：while 循环忘记写更新语句，或 for 循环的可迭代对象是无限的；
2. range () 函数的左闭右开 ：**range(1,10)**生成 1-9，不是 1-10，容易少循环一次；
3. break/continue 的作用范围 ：嵌套循环中，break/continue 只影响当前所在的循环，不影响外层循环；
4. 循环变量未初始化：while 循环的循环变量未初始化，导致条件判断报错。

5.3 调试技巧

1. 打印中间变量：在循环或条件中打印关键变量，查看其值是否符合预期；
2. 使用 IDE 的调试功能：用 PyCharm 的断点调试，一步一步执行代码，观察变量变化；
3. 简化代码：如果循环或条件太复杂，先简化成简单的示例，调试通过后再扩展。

---

总结

到这里，Python 语法基础的核心 ------ 条件语句（if-elif-else）、循环语句（while/for）、循环控制（break/continue）------ 就全部讲完了。

如果在学习过程中遇到问题，不妨回头看看这篇文章，或者查阅 Python 官方文档。编程是一个循序渐进的过程，只要坚持练习，你一定能从新手成长为 Python 高手！