Python 第三课，用 if 和循环把代码拼成完整程序
从“砖头”到“墙”：让代码拥有逻辑的大脑
本文深入讲解 Python 流程控制 的核心知识，涵盖 if/elif/else 条件判断、for 与 while 循环结构，并通过 猜数字游戏 实战项目帮助你将变量、输入输出、条件与循环融会贯通。掌握这些 编程逻辑 基础，是 Python 入门 的关键一步，让你真正理解如何让代码“思考”和“行动”。
本文是 Python 入门 系列第三篇，深入讲解 编程逻辑 的核心——流程控制。你将掌握
if/elif/else条件判断实现智能决策，学会使用for和while循环处理重复任务，并通过亲手编写一个完整的 猜数字游戏 实战项目，将变量、输入输出、条件与循环融会贯通，真正理解如何让代码“思考”和“行动”。
回顾前两篇博客，我们已经掌握了 Python 中最基础的“建筑材料”：变量就像是贴了标签的盒子，用来存储数据；数据类型则决定了盒子里装的是整数、小数还是文字。如果你只停留在这一层，那么你的程序就像是一堆整齐码放却毫无生气的砖头——它们存在，但不会自己动，更不会思考。
真正的编程魅力，始于你学会如何给这些砖头画上“图纸”，指挥它们按照特定的逻辑砌成一面墙，甚至建成一座大厦。这就是我们第三课的核心：流程控制。
在现实世界中，我们无时无刻不在做决策：“如果下雨，就带伞；否则，就戴帽子”；“只要还有精力，就继续跑步；一旦累了，就停下来”。计算机程序也是如此。没有逻辑控制的代码只能从头到尾机械地执行一遍，而拥有了 if 判断和循环结构的程序，才真正具备了“智能”，能够根据情况做出反应，或者不知疲倦地重复工作。今天，我们就来完成从“写单行代码”到“编写完整程序”的关键跨越。
程序的十字路口：if、elif 与 else 的条件判断
生活充满了选择，程序亦然。Python 使用 if 语句来处理这些分支逻辑。它的语法非常接近自然语言，读起来就像在说英语，这也是 Python 对新手友好的重要原因之一。
基础结构与缩进的铁律
一个最简单的条件判断结构如下：
age = 18
if age >= 18:
print("你已经成年了，可以独立承担责任。")
else:
print("你还是未成年人，需要监护人的照顾。")
这里有一个绝对不可触碰的红线：缩进（Indentation）。
在很多其他编程语言（如 C、Java、JavaScript）中，代码块是用花括号 {} 包裹起来的。但在 Python 中，缩进就是语法本身。if 语句冒号 : 后面的所有代码，必须统一向右缩进（通常是 4 个空格或 1 个 Tab 键）。如果缩进不一致，或者该缩进的地方没缩进，Python 解释器会直接抛出 IndentationError，程序根本无法运行。
避坑提示：千万不要混用 Tab 键和空格键！虽然肉眼看起来一样，但在计算机眼里它们是完全不同的字符。建议在你的代码编辑器中设置“将 Tab 自动转换为 4 个空格”，这是避免诡异报错的最佳实践。
多路分支：elif 的妙用
现实中的决策往往不是非黑即白的二元选择，而是有多种可能。比如考试成绩评级：90 分以上是优秀，80-89 是良好，60-79 是及格，60 以下是不及格。这时就需要 elif（else if 的缩写）来介入。
score = 85
if score >= 90:
grade = "优秀"
elif score >= 80:
grade = "良好"
elif score >= 60:
grade = "及格"
else:
grade = "不及格"
print(f"你的成绩等级是：{grade}")
程序执行时，会从上到下依次判断。一旦某个 if 或 elif 的条件满足（结果为 True），就会执行对应的代码块，并直接跳过后面所有的 elif 和 else 分支。这意味着条件的顺序非常重要。如果你把 if score >= 60 放在最前面，那么所有大于 60 分的成绩（包括 95 分）都会直接被判定为“及格”，后面的高分判断永远没有机会执行。
为了更直观地理解这个从上到下的判断流程，我们可以用下面的流程图来展示程序是如何“思考”的：
📝 小贴士：如何绘制这样的流程图？
上面的流程图是使用 Mermaid 语法绘制的，这是一种用文本描述图表的标记语言，在 Markdown 中可以直接使用。如果你也想在自己的博客或笔记中绘制流程图，可以按照以下基本语法：
- 基本结构：用 ```````mermaid ````和 ```````````包裹流程图代码
- 声明方向：
flowchart TD表示从上到下（Top-Down）的流程图- 节点类型：
[矩形]：普通节点（用方括号）([圆角矩形])：开始/结束节点（用圆括号和方括号）{菱形}：判断/条件节点（用花括号）- 连接线：
-->表示连接，-- 是 -->或-- 否 -->可以给连接线添加标签一个简单的示例（判断是否下雨）：
```mermaid flowchart TD Start([出门前]) --> Check{下雨了吗？} Check -- 是 --> TakeUmbrella[带伞] Check -- 否 --> WearHat[戴帽子] TakeUmbrella --> End([出门]) WearHat --> End ```渲染效果：
掌握了这些基础，你就能轻松地将复杂的程序逻辑可视化，让读者一目了然
📚 Mermaid 语法快速入门
如果你想在自己的博客或笔记中绘制类似的流程图，Mermaid 是一个非常方便的工具。下面是一个简明的语法指南：
1. 基本结构与方向声明
所有 Mermaid 流程图都以 flowchart 关键字开头，后接方向标识：
TD或TB：从上到下（Top-Down / Top to Bottom）LR：从左到右（Left to Right）RL：从右到左（Right to Left）BT：从下到上（Bottom to Top）
渲染效果：一个简单的从左到右的流程图
2. 节点类型与语法
- 矩形节点：
[文本内容] - 圆角矩形（开始/结束）：
([文本内容]) - 菱形（判断/条件）：
{文本内容} - 圆形节点：
((文本内容)) - 六边形节点：
{{文本内容}} - 平行四边形：
[/文本内容/]或[\文本内容\]
渲染效果：包含开始、处理、判断、结束节点的流程图
3. 连接线与标签
- 普通连接：
--> - 带标签的连接：
-- 标签文字 -->或-->|标签文字| - 虚线连接：
-.-> - 粗线连接：
==>
渲染效果：展示不同类型的连接线
4. 添加样式与注释
你可以为节点添加样式类，然后在样式部分定义样式：
```mermaid
flowchart TD
A[开始] --> B{判断}
B -->|是| C[成功]
B -->|否| D[失败]
classDef success fill:#d4edda,stroke:#155724,stroke-width:2px
classDef failure fill:#f8d7da,stroke:#721c24,stroke-width:2px
classDef decision fill:#fff3cd,stroke:#856404,stroke-width:2px
class C success
class D failure
class B decision
```
渲染效果：
5. 子图（Subgraph）
对于复杂的流程图，可以使用子图来组织相关节点：
```mermaid
flowchart TD
A[开始] --> B{条件判断}
subgraph 处理流程
C[步骤1] --> D[步骤2]
D --> E[步骤3]
end
B -->|满足| 处理流程
B -->|不满足| F[结束]
处理流程 --> G[完成]
```
渲染效果：
6. 完整示例：用户登录流程
下面是一个更完整的示例，展示了如何用 Mermaid 描述一个实际的业务流程：
```mermaid
flowchart TD
Start([用户访问]) --> LoginPage[登录页面]
LoginPage --> Input{输入账号密码}
Input -->|正确| Auth[身份验证]
Input -->|错误| Error1[显示错误提示]
Error1 --> Input
Auth --> Check{验证通过?}
Check -->|是| Welcome[欢迎页面]
Check -->|否| Error2[认证失败]
Error2 --> Retry{重试?}
Retry -->|是| Input
Retry -->|否| Exit([退出])
Welcome --> Dashboard[用户仪表盘]
Dashboard --> End([结束])
classDef green fill:#d4edda,stroke:#155724
classDef red fill:#f8d7da,stroke:#721c24
classDef blue fill:#cce5ff,stroke:#004085
class Welcome,Auth,Dashboard green
class Error1,Error2 red
class Start,LoginPage,Input,Check,Retry blue
```
使用建议：
- 在支持 Mermaid 的 Markdown 编辑器（如 CSDN 博客编辑器）中，直接使用三个反引号包裹代码即可
- 保持流程图简洁，避免节点过多导致难以阅读
- 使用有意义的节点名称，让流程图自解释
- 合理使用颜色和样式，但不要过度装饰
掌握了这些基础语法，你就能轻松创建各种流程图、时序图、类图等，让技术文档更加直观易懂！
！
现实中的决策往往不是非黑即白的二元选择，而是有多种可能。比如考试成绩评级：90 分以上是优秀，80-89 是良好，60-79 是及格，60 以下是不及格。这时就需要 elif（else if 的缩写）来介入。
score = 85
if score >= 90:
grade = "优秀"
elif score >= 80:
grade = "良好"
elif score >= 60:
grade = "及格"
else:
grade = "不及格"
print(f"你的成绩等级是：{grade}")
程序执行时，会从上到下依次判断。一旦某个 if 或 elif 的条件满足（结果为 True），就会执行对应的代码块，并直接跳过后面所有的 elif 和 else 分支。这意味着条件的顺序非常重要。如果你把 if score >= 60 放在最前面，那么所有大于 60 分的成绩（包括 95 分）都会直接被判定为“及格”，后面的高分判断永远没有机会执行。
常见的新手误区
在使用条件判断时，有两个细节容易出错：
- 赋值与比较混淆：在 Python 中，
=是赋值运算符（把右边的值给左边），而==才是相等比较运算符。写成if age = 18:是严重的语法错误，必须写成if age == 18:。 - input 的类型陷阱：当我们使用
input()获取用户输入时，无论用户输入的是数字还是文字，Python 默认都将其视为字符串。
如果不进行# 错误示范 user_age = input("请输入年龄：") if user_age > 18: # 报错！字符串不能和整数直接比较 print("成年") # 正确示范 user_age = int(input("请输入年龄：")) # 强制转换为整数 if user_age > 18: print("成年")int()或float()转换，程序会在比较时崩溃，或者产生不符合预期的逻辑结果（因为在字符串比较中，“9” 其实比 “10” 大，因为它是按字符逐个比的）。
快速排查指南
遇到问题不要慌！下表汇总了新手在流程控制中最常遇到的几种错误，帮你快速定位和解决：
| 错误现象 | 可能原因 | 解决方案 |
|---|---|---|
运行时报错 IndentationError: unexpected indent 或 IndentationError: expected an indented block |
缩进不一致（混用空格和 Tab）或该缩进的地方没缩进。 | 1. 检查 if/elif/else、for/while 循环后的代码块是否统一缩进（建议 4 个空格）。2. 在编辑器中开启“显示空白字符”功能，确保没有混用 Tab 和空格。 3. 设置编辑器“将 Tab 自动转换为空格”。 |
使用 input() 获取的数字与整数比较时报错 TypeError: '>' not supported between instances of 'str' and 'int' |
input() 返回的是字符串，不能直接与整数比较大小。 |
使用 int() 或 float() 函数将输入转换为数值类型：user_input = int(input("请输入数字：")) |
while 循环卡住，程序无响应（死循环） |
循环体内的条件变量没有更新，导致条件永远为 True。 |
检查 while 循环体内是否有改变条件变量的语句（如 count += 1）。确保循环有明确的退出路径。 |
for i in range(5): 只打印了 0-4，没有打印 5 |
误解了 range() 函数的“左闭右开”特性。 |
记住 range(start, stop) 包含 start，不包含 stop。要生成 1-5，应写 range(1, 6)。 |
if-elif-else 分支逻辑不符合预期（如高分被判定为低等级） |
elif 条件的顺序错误，导致先满足的条件“截胡”了后面的判断。 |
确保条件判断的顺序是从严格到宽松（例如先判断 score >= 90，再判断 score >= 80）。 |
代码块内的语句没有按预期执行（如 else 分支总是执行） |
可能误用了赋值运算符 = 而不是比较运算符 ==。 |
检查条件语句中是否写成了 if age = 18:（错误），应改为 if age == 18:（正确）。 |
让程序动起来：for 循环与 while 循环
如果说 if 语句让程序学会了“思考”，那么循环结构就让程序学会了“坚持”。处理大量重复性工作时，循环是不可或缺的工具。Python 提供了两种主要的循环结构：for 循环和 while 循环，它们各有特点，适用于不同的场景。
为了帮助你快速理解两者的区别并做出选择，下面这个对比表格总结了它们的关键特性：
| 特性 | for 循环 | while 循环 |
|---|---|---|
| 适用场景 | 遍历已知序列（列表、字符串、元组等）或执行固定次数的循环。 | 在条件为真时重复执行，循环次数通常不确定，取决于运行时条件变化。 |
| 语法结构 | for 变量 in 序列: # 循环体 |
while 条件: # 循环体 |
| 退出条件 | 遍历完序列中的所有元素，或遇到 break 语句。 |
当条件表达式变为 False，或遇到 break 语句。 |
| 典型用例 | 1. 遍历列表打印所有元素。 2. 使用 range() 执行固定次数的操作。3. 处理文件中的每一行。 |
1. 用户输入验证（直到输入正确为止）。 2. 游戏主循环（直到游戏结束）。 3. 监控某个状态（直到状态改变）。 |
| 核心关注点 | “遍历什么” – 关注要处理的数据集合。 | “何时停止” – 关注循环继续执行的条件。 |
| 常见陷阱 | 误用 range() 的“左闭右开”特性。 |
忘记在循环体内更新条件变量，导致死循环。 |
简单来说：当你明确知道要“循环多少次”或者“遍历哪些东西”时，用 for 循环；当你只知道“在什么条件下继续循环”时，用 while 循环。
下面我们来详细看看它们各自的具体用
为了更直观地理解 for 循环和 while 循环的执行流程，下面用流程图展示它们的典型执行路径：
流程图解读：
-
for 循环（左侧）：
- 初始化序列/迭代器：循环开始前准备好要遍历的数据
- 检查是否还有元素：每次迭代前自动检查
- 获取元素并执行循环体：自动将下一个元素赋值给循环变量
- 自动更新迭代器：无需手动操作，Python 自动处理
- 遍历完所有元素后结束
-
while 循环（右侧）：
- 检查条件是否为真：每次迭代前检查
- 条件为真则执行循环体
- 手动更新条件变量：必须在循环体内修改条件，否则可能死循环
- 条件为假时结束
核心区别总结：
- 初始化位置：
for循环在开始前初始化序列；while循环需要在循环外初始化条件变量 - 条件判断：
for检查"是否还有元素"；while检查"条件是否为真" - 迭代方式：
for自动迭代；while需手动更新条件变量 - 适用场景：
for适合已知迭代次数或遍历序列；while适合条件不确定的场景
法。
如果说 if 语句让程序学会了“思考”，那么循环结构就让程序学会了“坚持”。处理大量重复性工作时，循环是不可或缺的工具。
for 循环：遍历的艺术
for 循环最适合用于遍历一个序列（如列表、字符串）或执行固定次数的操作。在 Python 中，它通常搭配 range() 函数使用。
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in fruits:
print(f"我喜欢吃{fruit}")
这段代码会依次取出列表中的每一个元素，赋值给变量 fruit，然后执行打印操作。
当你需要控制循环次数时，range() 函数登场了。它是新手最容易踩坑的地方之一：左闭右开。
# 打印 0 到 4
for i in range(5):
print(i)
很多初学者会误以为 range(5) 会生成 1, 2, 3, 4, 5 或者 0, 1, 2, 3, 4, 5。实际上，range(start, stop) 生成的序列包含 start，但不包含 stop。所以 range(5) 等价于 [0, 1, 2, 3, 4]。如果你想要生成 1 到 5 的整数，必须写成 range(1, 6)。
记忆口诀：范围是“包头不包尾”，就像排队买票，号码牌发到了 5 号，但 5 号那个人还没轮到进场，只有 0 到 4 号进去了。
while 循环：条件的坚守
while 循环的逻辑更简单粗暴：只要条件为真，就一直执行。它常用于不知道具体要循环多少次，只知道结束条件的场景。
count = 0
while count < 5:
print(f"当前计数：{count}")
count += 1 # 千万别忘这一步！
这里有一个致命陷阱：如果在循环体内忘记修改导致条件变化的变量（比如上面的 count += 1），条件将永远为真，程序会陷入死循环，直到你强制终止它或计算机内存耗尽。在使用 while 时，务必时刻警惕：我的退出条件最终能达到吗？？
精细操控：break 与 continue
有时候，我们需要在循环过程中进行更精细的干预。比如，在查找数据时，一旦找到目标就想立刻停止搜索；或者在遍历数据时，想跳过某些不符合要求的项。这时就需要 break 和 continue。
- break：彻底跳出当前循环，不再执行剩余的迭代。
- continue：跳过本次循环剩余的代码，直接进入下一次迭代。
看一个具体的例子，我们要打印 1 到 10 之间的奇数，但如果遇到了 7，就停止打印：
for num in range(1, 11):
if num == 7:
print("遇到 7，停止任务！")
break # 直接结束整个循环
if num % 2 == 0:
continue # 如果是偶数，跳过本次，不执行下面的打印
print(num)
输出结果将是：```text
1
3
5
遇到 7，停止任务！
注意，7 之后的 8、9、10 都没有被处理，因为 `break` 直接终止了整个循环。而偶数没有被打印，是因为 `continue` 让它们跳过了 `print(num)` 这一行。这两个关键字是让程序逻辑更加灵活多变的关键。。
## 综合实战：动手写一个“猜数字游
## 综合实战：用户登录验证系统
现在，让我们通过一个更贴近实际应用的例子，将 `for` 循环、`while` 循环、`break` 和 `continue` 结合起来，构建一个简单的用户登录验证系统。
### 场景需求
假设我们有一个小型系统，需要：
1. 使用 `for` 循环遍历预设的用户名列表
2. 使用 `while` 循环给每个用户最多 3 次密码尝试机会
3. 使用 `break` 在密码正确时立即退出循环
4. 使用 `continue` 跳过无效的输入
### 完整代码实现
```python
# 综合实战：用户登录验证系统
# 演示 for 循环、while 循环、break 和 continue 的综合运用
def login_system():
"""用户登录验证系统"""
# 预设的用户名和密码数据库（实际应用中会存储在数据库或文件中）
users = {
"alice": "password123",
"bob": "bob@2024",
"charlie": "charlie#secure",
"diana": "diana_pass"
}
print("=" * 50)
print(" 🔐 用户登录验证系统")
print("=" * 50)
print("系统中有以下用户：")
# 使用 for 循环遍历所有用户名
for username in users.keys():
print(f" - {username}")
print()
# 主循环：遍历每个用户
for username, correct_password in users.items():
print(f"\n{'='*30}")
print(f"正在验证用户: {username}")
print(f"{'='*30}")
attempts = 0 # 记录尝试次数
max_attempts = 3 # 最大尝试次数
# while 循环：最多尝试 3 次密码
while attempts < max_attempts:
# 获取用户输入的密码
password = input(f"请输入 {username} 的密码（第 {attempts + 1} 次尝试）: ")
# 使用 continue 跳过空输入
if not password.strip(): # 如果输入为空或只有空格
print("⚠️ 密码不能为空，请重新输入！")
continue # 跳过本次循环的剩余部分，重新输入
# 检查密码是否正确
if password == correct_password:
print(f"✅ 登录成功！欢迎 {username}！")
print(f"🔓 您在第 {attempts + 1} 次尝试时成功登录")
break # 密码正确，跳出 while 循环，继续下一个用户
else:
attempts += 1
remaining = max_attempts - attempts
if remaining > 0:
print(f"❌ 密码错误！您还有 {remaining} 次尝试机会")
else:
print(f"🚫 密码错误！{username} 的账户已被锁定")
print(f"💡 提示：正确的密码是 '{correct_password}'（仅用于演示）")
# 检查是否因为密码正确而退出循环
if attempts < max_attempts and password == correct_password:
# 密码正确，继续验证下一个用户
continue
else:
# 3次尝试都失败，询问是否继续验证其他用户
choice = input("\n是否继续验证其他用户？(y/n): ").lower()
if choice != 'y':
print("\n👋 登录验证系统已退出")
break # 跳出 for 循环，结束程序
print("\n" + "="*50)
print(" 📊 登录验证统计")
print("="*50)
# 统计结果
print("所有用户验证完成！")
print("感谢使用本登录系统。")
print("\n💡 学习要点回顾：")
print("1. for 循环遍历字典的 items() 方法")
print("2. while 循环控制最大尝试次数")
print("3. break 在密码正确时立即退出循环")
print("4. continue 跳过无效输入")
print("5. 嵌套循环的综合运用")
# 运行登录系统
if __name__ == "__main__":
login_system()
代码解析与运行结果
1. 核心逻辑解析
# 1. for 循环遍历用户字典
for username, correct_password in users.items():
# 遍历每个用户，username 是键，correct_password 是值
# 2. while 循环控制密码尝试次数
while attempts < max_attempts:
# 最多尝试 3 次
# 3. continue 跳过无效输入
if not password.strip():
continue # 跳过空输入，重新循环
# 4. break 在密码正确时退出
if password == correct_password:
break # 跳出 while 循环
2. 运行结果示例
==================================================
🔐 用户登录验证系统
==================================================
系统中有以下用户：
- alice
- bob
- charlie
- diana
==============================
正在验证用户: alice
==============================
请输入 alice 的密码（第 1 次尝试）: 123
❌ 密码错误！您还有 2 次尝试机会
请输入 alice 的密码（第 2 次尝试）:
⚠️ 密码不能为空，请重新输入！
请输入 alice 的密码（第 2 次尝试）: password123
✅ 登录成功！欢迎 alice！
🔓 您在第 2 次尝试时成功登录
==============================
正在验证用户: bob
==============================
请输入 bob 的密码（第 1 次尝试）: wrong
❌ 密码错误！您还有 2 次尝试机会
请输入 bob 的密码（第 2 次尝试）: wrong_again
❌ 密码错误！您还有 1 次尝试机会
请输入 bob 的密码（第 3 次尝试）: still_wrong
🚫 密码错误！bob 的账户已被锁定
💡 提示：正确的密码是 'bob@2024'（仅用于演示）
是否继续验证其他用户？(y/n): y
==============================
正在验证用户: charlie
==============================
请输入 charlie 的密码（第 1 次尝试）: charlie#secure
✅ 登录成功！欢迎 charlie！
🔓 您在第 1 次尝试时成功登录
==============================
正在验证用户: diana
==============================
请输入 diana 的密码（第 1 次尝试）: diana_pass
✅ 登录成功！欢迎 diana！
🔓 您在第 1 次尝试时成功登录
==================================================
📊 登录验证统计
==================================================
所有用户验证完成！
感谢使用本登录系统。
💡 学习要点回顾：
1. for 循环遍历字典的 items() 方法
2. while 循环控制最大尝试次数
3. break 在密码正确时立即退出循环
4. continue 跳过无效输入
5. 嵌套循环的综合运用
关键知识点总结
-
for 循环的应用：
- 使用
for username in users.keys():遍历所有用户名 - 使用
for username, correct_password in users.items():同时获取键和值
- 使用
-
while 循环的应用：
- 使用
while attempts < max_attempts:控制最大尝试次数 - 在循环体内更新
attempts变量，避免死循环
- 使用
-
break 的巧妙使用：
- 在密码正确时立即跳出
while循环 - 在用户选择不继续时跳出
for循环
- 在密码正确时立即跳出
-
continue 的实用场景：
- 跳过空密码输入，要求用户重新输入
- 避免无效输入占用尝试次数
-
嵌套循环结构：
for循环在外层，处理每个用户while循环在内层，处理每个用户的密码尝试- 这种结构在实际开发中非常常见
扩展思考
你可以尝试修改这个程序来增加更多功能：
- 添加用户注册功能：让用户可以创建新账户
- 密码隐藏：使用
getpass模块隐藏密码输入 - 记录登录日志：将登录成功/失败记录到文件中
- 密码强度检查：在注册时检查密码复杂度
- 验证码功能：在多次失败后要求输入验证码
这个示例展示了如何将不同的流程控制结构组合起来解决实际问题。通过这样的综合练习，你能更好地理解各种循环和条件判断在实际场景中的应用方式。
戏”
光看不练假把式。现在，我们将前面学到的 import 模块导入、while 循环、多层 if-elif-else 判断、input 输入处理以及类型转换全部串联起来，完成一个经典的“猜数字游戏”。
游戏规则：
- 程序随机生成一个 1 到 100 之间的整数。
- 玩家输入猜测的数字。
- 程序提示猜大了、猜小了还是猜对了。
- 如果猜对了，游戏结束并统计猜测次数；如果猜错了，继续猜。
import random # 导入随机数模块
def guess_number_game():
# 1. 生成随机目标数
target = random.randint(1, 100)
attempts = 0
print("--- 欢迎来到猜数字游戏 ---")
print("我已经想好了一个 1 到 100 之间的整数。")
while True:
# 2. 获取用户输入并处理异常
user_input = input("请输入你的猜测：")
# 检查输入是否为纯数字，防止程序崩溃
if not user_input.isdigit():
print("❌ 输入无效，请输入一个整数！")
continue # 跳过本次循环，重新输入
guess = int(user_input)
attempts += 1 # 猜测次数加 1
# 3. 逻辑判断
if guess < target:
print("📉 太小了！再试一次。")
elif guess > target:
print("📈 太大了！再试一次。")
else:
print(f"🎉 恭喜你！猜对了！答案就是 {target}。")
print(f"你总共猜了 {attempts} 次。")
break # 猜对了，跳出循环，游戏结束
# 运行游戏
if __name__ == "__main__":
guess_number_game()
在这个小项目中，我们看到了完整程序的雏形：
- 利用
import random借力标准库，避免了重复造轮子。 - 使用
while True构建了一个持续运行的游戏主循环。 - 通过
if not user_input.isdigit()进行了防御性编程，防止用户输入字母导致int()转换报错，体现了程序的健壮性。 - 核心的
if-elif-else结构精准地控制了游戏的反馈逻辑。 - 最后的
break优雅地结束了游戏进试着把这段代码复制到你的编辑器中运行几次。你会发现，当你能亲手写出这样一个能与人交互、有逻辑反馈的程序时，那种成就感是单纯背诵语法条文无法比拟的。从变量到逻辑，从单行指令到完整流程，你已经迈出了成为程序员最关键的一步。接下来的学习中，你会接触到函数封装、文件操作以及更复杂的数据结构，但无论技术如何演进，今天所学的“判断”与“循环”始终是构建所有复杂系统的基石。编程的乐趣正是在不断的修改与探索中诞生的。为了帮助你更好地巩固所学知识，这里有几个具体的“挑战任务”，你可以尝试修改上面的代码来实### 🎯 挑战任务：扩展你的猜数字游戏
-
增加难度选择
- 目标：让玩家在游戏开始前选择难度（简单：1-50，中等：1-100，困难：1-200）。
- 提示：使用
input()获取难度选择，根据选择调整random.randint()的范围。 - 关键代码提示：
# 在生成 target 前添加 level = input("请选择难度（1-简单，2-中等，3-困难）：") if level == "1": max_num = 50 elif level == "2": max_num = 100 else: max_num = 200 target = random.randint(1, max_num)
-
记录最佳成绩
- 目标：记录玩家最少猜测次数，并在每次游戏结束时显示历史最佳成绩。
- 完整代码示例：
import random # 初始化最佳成绩为无穷大（表示还没有成绩） best_score = float('inf') def guess_number_game_with_best_score(): global best_score # 声明使用全局变量 target = random.randint(1, 100) attempts = 0 print("=" * 40) print("🎮 猜数字游戏 - 记录最佳成绩版") print("=" * 40) while True: user_input = input("请输入你的猜测（1-100）：") if not user_input.isdigit(): print("❌ 输入无效，请输入一个整数！") continue guess = int(user_input) attempts += 1 if guess < 1 or guess > 100: print("⚠️ 请输入1-100之间的数字！") continue if guess < target: print("📉 太小了！再试一次。") elif guess > target: print("📈 太大了！再试一次。") else: print(f"🎉 恭喜你！猜对了！答案就是 {target}。") print(f"📊 本次猜测次数：{attempts} 次") # 更新最佳成绩 if attempts < best_score: best_score = attempts print(f"🏆 恭喜！你创造了新的最佳成绩：{attempts} 次！") else: print(f"📈 历史最佳成绩：{best_score} 次") print("=" * 40) break # 运行游戏 if __name__ == "__main__": guess_number_game_with_best_score() - 关键步骤说明：
- 在函数外部定义
best_score = float('inf')，float('inf')表示无穷大，确保第一次游戏成绩一定会被记录 - 在函数内部使用
global best_score声明使用全局变量 - 游戏结束后比较
attempts和best_score，如果本次成绩更好则更新 - 每次游戏都显示当前成绩和历史最佳成绩
- 在函数外部定义
-
美化输出界面
- 目标：让游戏界面更友好，比如显示猜测进度条、使用更丰富的表情符号、添加颜色（如果环境支持）。
- 完整代码示例：
import random import time def guess_number_game_beautified(): target = random.randint(1, 100) attempts = 0 guess_history = [] # 记录猜测历史 # 美化界面 print("✨" * 25) print(" 🎯 猜数字游戏豪华版 🎯") print("✨" * 25) print("\n📝 游戏规则：") print(" • 我随机生成了一个 1-100 的数字") print(" • 你需要猜出这个数字是多少") print(" • 我会提示你猜大了还是猜小了") print(" • 看看你能用多少次猜中！\n") print("─" * 50) while True: attempts += 1 # 显示进度条 progress = min(attempts * 2, 50) # 最多显示50个字符 print(f"\n🔄 第 {attempts} 次尝试") print(f"📊 进度：[{'█' * progress}{'░' * (50 - progress)}]") # 获取用户输入 try: guess = int(input("\n🎲 请输入你的猜测（1-100）：")) except ValueError: print("❌ 输入无效！请输入一个整数。") attempts -= 1 # 这次尝试不算 continue if guess < 1 or guess > 100: print("⚠️ 请输入1-100之间的数字！") attempts -= 1 continue # 记录猜测历史 guess_history.append(guess) # 智能反馈系统 difference = abs(target - guess) if guess == target: print("\n" + "🎉" * 20) print(" 🏆 太棒了！你猜对了！ 🏆") print("🎉" * 20) print(f"\n📈 目标数字：{target}") print(f"📊 猜测次数：{attempts} 次") print(f"📝 猜测历史：{guess_history}") # 根据表现给出评价 if attempts <= 5: print("🌟 评价：天才！简直不可思议！") elif attempts <= 10: print("👍 评价：优秀！你的直觉很准！") elif attempts <= 15: print("😊 评价：不错！继续努力！") else: print("💪 评价：有进步空间，多玩几次会更好！") print("\n" + "─" * 50) print("感谢游玩！期待下次再见！ 👋") break elif guess < target: if difference <= 5: print("🔥 很接近了！再大一点点！") elif difference <= 15: print("📈 有点小，再试试大一点的数字") else: print("📉 太小了，往大的方向猜") else: # guess > target if difference <= 5: print("🔥 就差一点！再小一点点！") elif difference <= 15: print("📉 有点大，试试小一点的数字") else: print("📈 太大了，往小的方向猜") # 运行游戏 if __name__ == "__main__": guess_number_game_beautified() - 美化功能说明：
- 装饰性元素：使用表情符号和分隔线让界面更生动
- 进度条：用
█和░字符模拟进度条，直观显示尝试次数 - 智能反馈：根据与目标数字的差距给出不同提示
- 历史记录：记录每次猜测的数字，游戏结束时展示
- 表现评价：根据猜测次数给出不同的评价
- 异常处理：使用
try-except更优雅地处理输入错误
动手建议：不要试图一次性完成所有功能！先从第一个任务开始，成功后再尝试下一个。每完成一个功能，你都会对 Python 的控制流有更深的理解。记住，编
📖 核心术语速查
为了帮助你更好地回顾和掌握本文的核心概念，这里整理了本文涉及的关键编程术语及其简要说明：
| 术语 | 英文对应 | 简要定义 | 文中首次出现位置 |
|---|---|---|---|
| 流程控制 | Flow Control | 程序根据条件决定执行路径或重复执行特定代码块的能力，是编程逻辑的核心。 | 文章标题下方摘要 |
| 条件判断 | Conditional Statements | 通过 if、elif、else 等关键字，让程序根据条件真假选择不同的执行路径。 |
「程序的十字路口：if、elif 与 else 的条件判断」 |
| 循环 | Loops | 重复执行某段代码的结构，Python 中主要有 for 循环和 while 循环两种。 |
「让程序动起来：for 循环与 while 循环」 |
| 缩进 | Indentation | Python 中用于标识代码块层次的空格或 Tab，是语法的一部分，必须保持一致。 | 「基础结构与缩进的铁律」 |
| 死循环 | Infinite Loop | while 循环中因条件永远为真而无法退出的情况，会导致程序卡死。 |
「while 循环：条件的坚守」 |
| 左闭右开 | Left-closed, Right-open | range() 函数等 Python 区间表示法的特性：包含起始值，不包含结束值。 |
「for 循环：遍历的艺术」 |
| 遍历 | Iteration/Traversal | 按顺序访问序列（如列表、字符串）中的每个元素的过程，通常使用 for 循环实现。 |
「for 循环：遍历的艺术」 |
| 序列 | Sequence | 一组有序的数据集合，如列表、字符串、元组等，可以被 for 循环遍历。 |
「for 循环与 while 循环」对比表格 |
| 防御性编程 | Defensive Programming | 在编写代码时预先考虑可能的错误输入或异常情况，并采取措施防止程序崩溃。 | 「综合实战：动手写一个“猜数字游戏”」 |
结语：从流程控制到编程思维
恭喜你！通过这篇教程，你已经掌握了 Python 流程控制的核心概念——条件判断与循环结构。从 if/elif/else 的智能决策，到 for 和 while 的重复执行，再到 break 和 continue 的精细控制，你已经拥有了让代码“思考”和“行动”的基本能力。
更重要的是，通过亲手编写“猜数字游戏”这个完整的实战项目，你将变量、输入输出、条件判断和循环有机地结合在了一起，体验了从零构建一个可运行程序的完整过程。这正是编程学习的正确路径：先理解概念，再动手实践，最后通过扩展项目来巩固和深化理解。
记住今天学到的几个关键点：
- 缩进是 Python 的语法，不是可选项
- 条件判断要讲究顺序，
elif的顺序决定逻辑优先级 for循环用于遍历已知序列，while循环用于条件不确定的场景- 防御性编程很重要，处理用户输入时要考虑异常情况
- 编程是实践的艺术，多写代码比死记硬背更有效
流程控制是编程思维的基石。无论你将来学习函数、类、模块，还是接触更复杂的数据结构和算法，今天学到的“判断”与“循环”思想都会贯穿始终。它们就像乐高积木中的基础模块，虽然简单，却能组合出无限可能。
下一步学习方向
掌握了流程控制，你已经具备了编写基础程序的能力。接下来，我建议你按照以下路径继续深入学习：
-
函数封装：将重复的代码块封装成函数，提高代码的复用性和可读性。学习如何定义函数、传递参数、返回值，这是构建复杂程序的基础。
-
数据结构：探索列表、字典、元组和集合等数据结构。了解它们的特点和适用场景，学会用合适的数据结构存储和处理数据。
-
文件操作：学习如何读写文件，让程序能与外部世界交互。这是数据处理、日志记录等实际应用的基础。
-
错误处理：深入了解
try-except异常处理机制，编写更健壮的程序，能够优雅地处理各种运行时错误。 -
模块化编程：学习如何将代码组织到不同的模块和包中，理解
import语句的更多用法，构建可维护的大型项目。
保持学习的热情
编程学习是一个螺旋上升的过程。不要因为遇到困难而气馁，每个程序员都曾经历过你现在所处的阶段。最好的学习方法就是动手实践：
- 完成本文的挑战任务：尝试为猜数字游戏增加难度选择、记录最佳成绩、美化界面等功能
- 创造自己的小项目：用今天学到的知识编写一个简单的计算器、待办事项列表或温度转换器
- 参与开源项目：阅读他人的代码，学习优秀的编程实践
- 坚持每日编码：哪怕每天只写20行代码，长期积累也会带来质的飞跃
编程的世界广阔而精彩，今天你迈出的这一步只是开始。保持好奇心，勇于尝试，享受解决问题的乐趣。当你看到自己编写的程序真正运行起来，解决实际问题时，那种成就感是无与伦比的。
期待在下一篇教程中与你继续探索 Python 的更多可能性！如果你在学习过程中遇到任何问题，欢迎在评论区留言交流。
本文是 Python 入门系列第三篇，前两篇分别讲解了变量与数据类型、输入输出与运算符。如果你刚刚开始学习 Python，建议按顺序阅读整个系列，建立完整的知识体系。
刚开始学习 Python，建议按顺序阅读整个系列
第一课，学习规划和基础知识
第二课，变量命名与引号用法
更多推荐
17
0- 0
已为社区贡献8条内容
所有评论(0)