Python 学习笔记（第三期）——流程控制：条件判断与循环结构

Python 学习笔记（第三期）------流程控制：条件判断与循环结构

知识衔接：

Python 学习笔记（第一期）------基础语法（上篇）：环境搭建与数据基石

Python 学习笔记（第二期）------基础语法（下篇）：运算符全解与实战演练

更多Python知识：Python基础入门

我的主页：AOwhisky，这里有更多运维系统性知识整理和其他有趣内容，欢迎与我一起探讨学习~

📖 引言：让程序拥有"思考"与"重复"的能力

回顾前两期，我们已经掌握了Python的基础语法和运算符，能够写出顺序执行的代码------就像一份按部就班的流水账：先做A，再做B，最后做C。

但现实世界中的问题远比"顺序执行"复杂。以日常生活中的决策为例：

• 如果 今天下雨，就 带伞；否则 ，不带伞。------这是条件判断。
• 每天 早晨起床后，都要刷牙、洗脸、吃早餐。------这是循环重复。

程序也一样。一个优秀的程序必须具备根据条件做出不同反应 的能力，以及高效地重复执行某段代码 的能力。这正是本期要学习的核心内容------流程控制。

如果说变量和运算符是Python的"血肉"，那么流程控制就是Python的"骨架"和"神经系统"------它决定了程序的执行走向，让代码真正变得"智能"起来。
--- Compiled and Authored by Whisky --- July 9 th, 2026

📑 本期目录

1. 条件语句（if、if-else、if-elif-else）
2. 条件嵌套（if 嵌套）
3. 循环语句（while 循环）
4. 循环语句（for 循环与 range()）
5. 循环嵌套
6. 跳转语句（break 与 continue）
7. 综合实战演练（五个完整案例）
8. 总结与知识点一览表

正文

一、条件语句

条件语句让程序具备了"判断能力"------根据条件是否成立，决定执行哪一段代码。

1.1 if 语句（单分支）

if 语句是最简单的条件语句：如果条件成立（布尔值为 True），就执行后面的代码块；否则跳过。

if 条件表达式:
    代码块

# 示例：判断考试成绩是否及格
score = 88
if score >= 60:
    print("考试及格！")

运行结果：

考试及格！

流程图理解：

可以这样理解 if 的执行流程：程序运行到 if 语句时，就像站在一个岔路口------如果条件为真，就走左边的路（执行代码块）；如果条件为假，就走右边的路（跳过代码块，继续向下执行）。

1.2 if-else 语句（双分支）

有些场景不仅需要处理"条件成立"的情况，还需要处理"条件不成立"的情况------这时就用 if-else。

if 条件表达式:
    代码块1   # 条件成立时执行
else:
    代码块2   # 条件不成立时执行

# 示例：判断考试成绩是否及格
score = 55
if score >= 60:
    print("考试及格！")
else:
    print("考试不及格！")

运行结果：

考试不及格！

💡 白话理解 ：if-else 就像岔路口的两个分支------一条通往"及格"区，一条通往"不及格"区。条件为真走第一条路，条件为假走第二条路。两条路必选其一。

1.3 if-elif-else 语句（多分支）

当需要判断的条件超过两个时，就用到 if-elif-else。elif 是 else if 的缩写，可以有任意多个。

if 条件1:
    代码块1
elif 条件2:
    代码块2
elif 条件3:
    代码块3
...
else:
    代码块n   # 所有条件都不成立时执行

# 示例：根据分数段评定等级
score = 84

if score >= 90:
    print("等级：优秀")
elif score >= 75:
    print("等级：良好")
elif score >= 60:
    print("等级：合格")
else:
    print("等级：不合格")

运行结果：

等级：良好

执行流程：

1. 判断 score >= 90 ------ 不成立，继续向下。
2. 判断 score >= 75 ------ 成立，执行 print("等级：良好")，然后跳过 剩余的 elif 和 else。
3. 后续条件不再判断。

⚠️ 常见误区 ：在 if-elif-else 结构中，一旦某个条件成立，后面的所有 elif 和 else 都会被跳过。因此条件的顺序至关重要------应当先判断范围更严格的条件，再判断范围更宽松的条件。

# ❌ 错误的顺序
score = 95
if score >= 60:       # 这个条件先成立
    print("合格")
elif score >= 90:     # 永远不会执行到这里
    print("优秀")
# 输出：合格（但实际应该是优秀）

# ✅ 正确的顺序（从严格到宽松）
if score >= 90:
    print("优秀")
elif score >= 60:
    print("合格")

1.4 if 嵌套（外层 + 内层）

有时，一个条件的判断依赖于另一个条件先被满足------这就是嵌套。就像火车站乘车：必须先通过检票 （外层条件），才能进入安检（内层条件），两层都通过才能进站。

if 外层条件:
    if 内层条件:
        代码块

经典案例：根据年份和月份计算该月的天数

year = 2024
month = 2

if month in [1, 3, 5, 7, 8, 10, 12]:
    print(f"{month}月有31天")
elif month in [4, 6, 9, 11]:
    print(f"{month}月有30天")
elif month == 2:                      # 2月特殊，需要嵌套判断闰年
    if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
        print(f"{year}年{month}月有29天")   # 闰年
    else:
        print(f"{year}年{month}月有28天")   # 平年
else:
    print("输入的月份无效")

运行结果：

2024年2月有29天

逐行解读：

• 首先判断月份属于31天组还是30天组。
• 如果月份是2月，进入嵌套的 if-else，进一步判断年份是否为闰年。
• 闰年判断条件：(year % 400 == 0) or (year % 4 == 0 and year % 100 != 0)------能被400整除，或者能被4整除但不能被100整除。

💡 思维误区 ：新手容易把嵌套条件写成扁平化的多个 if，导致逻辑混乱。记住------只有在外层条件满足的情况下，内层条件才有判断的意义。如果外层条件不成立，内层条件根本不应该被执行。

二、循环语句

循环语句让程序具备了"重复执行"的能力。想象一下，如果让你输出1到100的数字，你不会傻傻地写100行 print()------循环就是用来解决这类重复劳动的。

2.1 while 循环（条件循环）

while 循环在条件为 True 时不断重复执行代码块，直到条件变为 False。

while 条件表达式:
    代码块

案例：计算 1 + 2 + 3 + ... + 10 的和

i = 1          # 循环变量初始化
total = 0      # 累加器

while i <= 10:
    total += i
    i += 1     # 循环变量更新（非常重要！）

print(f"1到10的和为：{total}")

运行结果：

1到10的和为：55

执行流程追踪：

循环次数	i 的值	条件 i <= 10	total 的值
第1次	1	True	1
第2次	2	True	3
第3次	3	True	6
...	...	...	...
第10次	10	True	55
第11次	11	False	退出循环

⚠️ 无限循环（死循环）警告：

while True:
    print("无限循环")   # 永远停不下来！

如果 while 的条件永远为 True，且循环体内没有 break 语句，程序将永远执行下去，直到耗尽系统资源或强制终止。务必确保循环变量会向终止条件方向变化，或者设置合理的退出机制。

2.2 for 循环（遍历循环）

for 循环用于遍历可迭代对象（如字符串、列表、元组、字典、range() 生成的序列等）中的每个元素。

for 临时变量 in 可迭代对象:
    代码块

案例1：遍历字符串中的每个字符

for char in "Python":
    print(char)

运行结果：

P
y
t
h
o
n

案例2：遍历列表中的每个元素

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

运行结果：

我喜欢吃苹果
我喜欢吃香蕉
我喜欢吃橙子

2.3 range() 函数（生成整数序列）

range() 是 for 循环最常用的搭档，它生成一个整数序列，有三种调用方式：

调用方式	说明	示例	生成的序列
range(stop)	从 0 到 stop-1	range(5)	0, 1, 2, 3, 4
range(start, stop)	从 start 到 stop-1	range(2, 6)	2, 3, 4, 5
range(start, stop, step)	从 start 到 stop-1，步长为 step	range(1, 10, 2)	1, 3, 5, 7, 9

# 输出0到4
for i in range(5):
    print(i, end=" ")   # 0 1 2 3 4

print()  # 换行

# 输出1到10中的偶数
for i in range(2, 11, 2):
    print(i, end=" ")   # 2 4 6 8 10

三、循环嵌套

循环内部可以再包含循环，这称为循环嵌套。外层循环每执行一次，内层循环会完整地执行一轮。

3.1 while 循环嵌套

# 使用 while 嵌套打印直角三角形
row = 1
while row <= 5:           # 外层循环控制行数
    col = 1
    while col <= row:     # 内层循环控制每行的星号数
        print("*", end="")
        col += 1
    print()               # 每行结束后换行
    row += 1

运行结果：

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

3.2 for 循环嵌套

# 使用 for 嵌套打印九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} × {i} = {i * j}", end="\t")
    print()

运行结果：

1 × 1 = 1
1 × 2 = 2    2 × 2 = 4
1 × 3 = 3    2 × 3 = 6    3 × 3 = 9
1 × 4 = 4    2 × 4 = 8    3 × 4 = 12   4 × 4 = 16
1 × 5 = 5    2 × 5 = 10   3 × 5 = 15   4 × 5 = 20   5 × 5 = 25
1 × 6 = 6    2 × 6 = 12   3 × 6 = 18   4 × 6 = 24   5 × 6 = 30   6 × 6 = 36
1 × 7 = 7    2 × 7 = 14   3 × 7 = 21   4 × 7 = 28   5 × 7 = 35   6 × 7 = 42   7 × 7 = 49
1 × 8 = 8    2 × 8 = 16   3 × 8 = 24   4 × 8 = 32   5 × 8 = 40   6 × 8 = 48   7 × 8 = 56   8 × 8 = 64
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

执行流程解读：

• 外层循环 i 从 1 到 9，代表乘法表的行（被乘数）。
• 内层循环 j 从 1 到 i，代表每行的列数（乘数）。
• end="\t" 用制表符对齐输出，print() 换行。

四、跳转语句

循环默认会一直执行到条件不成立为止，但有时我们需要提前终止循环或跳过某次迭代------这时就用到了 break 和 continue。

4.1 break 语句（终止整个循环）

break 用于立即结束当前所在的整个循环，循环体之后的代码继续执行。

# 在字符串中查找某个字符，找到后立即停止
text = "Python"
for char in text:
    if char == "o":
        print(f"找到了字符 '{char}'，停止搜索！")
        break
    print(f"当前字符：{char}")

运行结果：

当前字符：P
当前字符：y
当前字符：t
当前字符：h
找到了字符 'o'，停止搜索！

注意 ：break 后的 print(f"当前字符：{char}") 在找到 'o' 后不再执行。

break 与嵌套循环 ：break 只会终止它所在的那一层循环，外层循环不受影响。

for i in range(3):
    print(f"外层循环：{i}")
    for j in range(5):
        if j == 2:
            break              # 只终止内层循环
        print(f"  内层循环：{j}")

运行结果：

外层循环：0
  内层循环：0
  内层循环：1
外层循环：1
  内层循环：0
  内层循环：1
外层循环：2
  内层循环：0
  内层循环：1

4.2 continue 语句（跳过本次迭代）

continue 用于跳过当前这一次循环中剩余的代码，直接进入下一次循环。

# 输出字符串中除 'o' 之外的所有字符
text = "Python"
for char in text:
    if char == "o":
        continue      # 遇到 'o' 时跳过本次循环
    print(char, end="")

运行结果：

Pythn

break 与 continue 对比：

对比维度	break	continue
作用	结束整个循环	跳过本次循环
循环是否继续	不再继续	继续下一次循环
适用场景	提前找到目标后退出	某些情况不需要处理，跳过即可

# 对比示例
print("=== 使用 break ===")
for i in range(5):
    if i == 3:
        break
    print(i)   # 输出 0, 1, 2

print("=== 使用 continue ===")
for i in range(5):
    if i == 3:
        continue
    print(i)   # 输出 0, 1, 2, 4

五、综合实战演练

实战一：计算器（四则运算）

需求描述：用户输入两个数字和一个运算符（+、-、*、/），程序输出计算结果。要求支持除数为0时的错误提示。

涉及知识点 ：if-elif-else 多分支、算术运算符、input() 输入处理、类型转换、isdigit() 输入校验

# 简单计算器（增强版：带输入校验）

print("=" * 30)
print("     简 易 计 算 器")
print("=" * 30)

# 获取第一个数字（带校验）
while True:
    num1_input = input("请输入第一个数字：")
    # 判断输入是否为有效的数字（支持负数和小数）
    # 这里简化处理：先判断是否纯数字，负数和小数需要额外处理
    if num1_input.lstrip('-').replace('.', '', 1).isdigit():
        num1 = float(num1_input)
        break
    else:
        print("❌ 输入无效，请输入一个有效的数字！")

# 获取运算符
operator = input("请输入运算符（+  -  *  /）：")
if operator not in ['+', '-', '*', '/']:
    print("❌ 不支持的运算符！")
    exit()

# 获取第二个数字（带校验，且不能为0当除法时）
while True:
    num2_input = input("请输入第二个数字：")
    if num2_input.lstrip('-').replace('.', '', 1).isdigit():
        num2 = float(num2_input)
        if operator == '/' and num2 == 0:
            print("❌ 除数不能为0，请重新输入！")
            continue
        break
    else:
        print("❌ 输入无效，请输入一个有效的数字！")

# 执行计算
if operator == '+':
    result = num1 + num2
elif operator == '-':
    result = num1 - num2
elif operator == '*':
    result = num1 * num2
elif operator == '/':
    result = num1 / num2

print("=" * 30)
print(f"计算结果是：{num1} {operator} {num2} = {result}")
print("=" * 30)

运行结果示例：

==============================
     简 易 计 算 器
==============================
请输入第一个数字：10
请输入运算符（+  -  *  /）：/
请输入第二个数字：0
❌ 除数不能为0，请重新输入！
请输入第二个数字：3
==============================
计算结果是：10.0 / 3.0 = 3.3333333333333335
==============================

💡 扩展知识点：

• num1_input.lstrip('-').replace('.', '', 1).isdigit() 是一个常用的数字校验技巧：先去掉可能的负号，再把小数点替换为空（只替换一次），然后判断剩余部分是否都是数字。
• while True + break 组合实现了"反复询问直到输入合法为止"的鲁棒逻辑。

实战二：猜数字游戏

需求描述：程序随机生成一个1~100之间的数字，用户有7次机会猜数字。每次猜测后，程序提示"猜大了"或"猜小了"。如果猜中则胜利，7次用完未猜中则失败。

涉及知识点 ：while 循环、break、比较运算符、逻辑运算符、random 模块

# 猜数字游戏

import random

# 生成随机数（1~100）
secret = random.randint(1, 100)
max_attempts = 7
attempts = 0

print("=" * 40)
print("      🎯 猜数字游戏")
print(f"   你有 {max_attempts} 次机会，猜一个 1~100 之间的数字")
print("=" * 40)

while attempts < max_attempts:
    # 剩余次数
    remaining = max_attempts - attempts
    guess = input(f"还剩 {remaining} 次机会，请输入你猜的数字：")

    # 输入校验
    if not guess.isdigit():
        print("❌ 请输入有效的整数！")
        continue

    guess = int(guess)
    attempts += 1

    if guess < 1 or guess > 100:
        print("❌ 数字范围在 1~100 之间，请重新输入！")
        # 不消耗尝试次数？这里设计为消耗，让玩家更认真
        continue

    if guess == secret:
        print(f"🎉 恭喜你！猜对了！答案就是 {secret}")
        print(f"你用了 {attempts} 次机会猜中！")
        break
    elif guess > secret:
        print("📈 猜大了，再小一点！")
    else:
        print("📉 猜小了，再大一点！")

else:
    # while 循环正常结束（没有被 break 打断）时执行
    print("=" * 40)
    print(f"😢 很遗憾，7次机会用完了......")
    print(f"正确答案是：{secret}")
    print("=" * 40)

运行结果示例：

========================================
      🎯 猜数字游戏
    你有 7 次机会，猜一个 1~100 之间的数字
========================================
还剩 7 次机会，请输入你猜的数字：50
📈 猜大了，再小一点！
还剩 6 次机会，请输入你猜的数字：25
📉 猜小了，再大一点！
还剩 5 次机会，请输入你猜的数字：37
🎉 恭喜你！猜对了！答案就是 37
你用了 3 次机会猜中！

💡 扩展知识点：

• while ... else 是 Python 独有的语法：当循环正常结束（没有被 break 打断）时，执行 else 子句。
• random.randint(1, 100) 包含两端边界（1和100都可能被抽中）。
• guess.isdigit() 判断输入是否全为数字，防止程序崩溃。

实战三：逢7拍手游戏

需求描述 ：从1开始数到100，如果数字包含7 （如7、17、27、70~79）或者是7的倍数（如14、21、28），就输出"👏"代表拍手，否则输出数字本身。

涉及知识点 ：for 循环、range()、取余运算 %、字符串成员运算 in、逻辑运算符 or

# 逢7拍手游戏（输出1~100中需要拍手的数字）

print("逢7拍手游戏：数字包含7或者是7的倍数 → 👏")
print("-" * 50)

for num in range(1, 101):
    # 判断条件：包含数字7 或 是7的倍数
    if ("7" in str(num)) or (num % 7 == 0):
        print("👏", end=" ")
    else:
        print(num, end=" ")

    # 每10个数字换行，让输出更整齐
    if num % 10 == 0:
        print()

运行结果（部分）：

逢7拍手游戏：数字包含7或者是7的倍数 → 👏
--------------------------------------------------
1 2 3 4 5 6 👏 8 9 10
11 12 13 👏 15 16 👏 18 19 20
👏 22 23 24 25 26 👏 👏 29 30
31 32 33 34 👏 36 👏 38 39 40
41 👏 43 44 45 46 👏 48 👏 50
...

条件拆解：

• "7" in str(num)：将数字转为字符串，判断是否包含字符 '7'。例如 str(27) → "27" → "7" in "27" 为 True。
• num % 7 == 0：判断是否是7的倍数，余数为0即为倍数。

实战四：打印五子棋棋盘

需求描述：用户输入棋盘大小（如15，代表15×15），程序打印出带有行列坐标的五子棋棋盘。

涉及知识点 ：for 循环嵌套、字符串拼接、条件判断（打印边界点）

# 打印五子棋棋盘

size = int(input("请输入棋盘大小（如15表示15×15）："))

# 打印列标（横向坐标）
print("   ", end="")                         # 行标前导空格
for col in range(1, size + 1):
    print(f"{col:2}", end="")                # :2 表示占2个字符宽度
print()                                      # 换行

# 打印棋盘主体
for row in range(1, size + 1):
    # 打印行标（纵向坐标）
    print(f"{row:2}", end=" ")

    for col in range(1, size + 1):
        # 判断是否为交叉点（默认打印十字符号）
        if row == 1 and col == 1:
            print("┌", end=" ")              # 左上角
        elif row == 1 and col == size:
            print("┐", end=" ")              # 右上角
        elif row == size and col == 1:
            print("└", end=" ")              # 左下角
        elif row == size and col == size:
            print("┘", end=" ")              # 右下角
        elif row == 1:
            print("┬", end=" ")              # 上边线
        elif row == size:
            print("┴", end=" ")              # 下边线
        elif col == 1:
            print("├", end=" ")              # 左边线
        elif col == size:
            print("┤", end=" ")              # 右边线
        else:
            print("┼", end=" ")              # 内部交叉点
    print()                                  # 每行结束后换行

运行结果（size=8 时）：

请输入棋盘大小（如15表示15×15）：8
    1 2 3 4 5 6 7 8
 1 ┌ ┬ ┬ ┬ ┬ ┬ ┬ ┐
 2 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 3 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 4 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 5 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 6 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 7 ├ ┼ ┼ ┼ ┼ ┼ ┼ ┤
 8 └ ┴ ┴ ┴ ┴ ┴ ┴ ┘

💡 扩展思路 ：如果需要打印带落子标记的棋盘（如 ● 表示黑子，○ 表示白子），可以将棋盘状态存储在一个二维列表中，打印时根据列表中的值选择对应的符号输出。

实战五：房贷计算器

需求描述：用户选择贷款类型（商业贷款/公积金贷款），输入贷款金额（万元）、期限（年）、利率（%），程序计算并输出每月月供、支付利息和还款总额。

涉及知识点 ：算术运算符（乘、除、幂 **）、if-elif-else 多分支、input() 输入、f-string 格式化、while 循环（菜单选择）

核心公式：

• 月利率 = 年利率 / 12
• 还款月数 = 贷款期限 × 12
• 每月月供 = 贷款金额 × 月利率 × (1 + 月利率)^还款月数 / (1 + 月利率)\^还款月数 - 1
• 还款总额 = 每月月供 × 还款月数
• 支付利息 = 还款总额 - 贷款金额

基准利率参考：

贷款类型	期限	年利率
商业贷款	5年及以下	4.75%
商业贷款	5年以上	4.90%
公积金贷款	5年及以下	2.75%
公积金贷款	5年以上	3.25%

# 房贷计算器

print("=" * 50)
print("          🏠 房 贷 计 算 器")
print("=" * 50)

# 选择贷款类型
print("\n请选择贷款类型：")
print("1. 商业贷款")
print("2. 公积金贷款")
loan_type = input("请输入编号（1 或 2）：")

# 输入贷款信息
loan_amount = float(input("请输入贷款金额（单位：万元）：")) * 10000  # 转为元
years = int(input("请输入贷款期限（单位：年）："))
rate_input = float(input("请输入年利率（单位：%，如 4.9）：")) / 100  # 转为小数

# 根据贷款类型确认利率（如果用户不手动输入，可使用默认值）
# 这里使用用户输入的值，同时提供基准利率参考
print("\n" + "-" * 50)

# 计算月利率和还款月数
monthly_rate = rate_input / 12
total_months = years * 12

# 计算每月月供（等额本息）
# 每月月供 = 贷款金额 × 月利率 × (1 + 月利率)^还款月数 / ((1 + 月利率)^还款月数 - 1)
if monthly_rate == 0:
    # 利率为0时，直接平均分摊
    monthly_payment = loan_amount / total_months
else:
    monthly_payment = loan_amount * monthly_rate * (1 + monthly_rate) ** total_months / ((1 + monthly_rate) ** total_months - 1)

total_payment = monthly_payment * total_months
total_interest = total_payment - loan_amount

# 输出结果
print("\n📊 计算结果如下：")
print("-" * 50)
print(f"贷款类型：{'商业贷款' if loan_type == '1' else '公积金贷款'}")
print(f"贷款金额：{loan_amount / 10000:.0f} 万元")
print(f"贷款期限：{years} 年（{total_months} 个月）")
print(f"年利率：{rate_input * 100:.2f}%")
print(f"月利率：{monthly_rate * 100:.4f}%")
print("-" * 50)
print(f"💰 每月月供参考：{monthly_payment:.2f} 元")
print(f"💰 支付利息总额：{total_interest:.2f} 元")
print(f"💰 还款总额：{total_payment:.2f} 元")
print("=" * 50)

运行结果示例：

==================================================
          🏠 房 贷 计 算 器
==================================================

请选择贷款类型：
1. 商业贷款
2. 公积金贷款
请输入编号（1 或 2）：1
请输入贷款金额（单位：万元）：100
请输入贷款期限（单位：年）：30
请输入年利率（单位：%，如 4.9）：4.9

--------------------------------------------------

📊 计算结果如下：
--------------------------------------------------
贷款类型：商业贷款
贷款金额：100 万元
贷款期限：30 年（360 个月）
年利率：4.90%
月利率：0.4083%
--------------------------------------------------
💰 每月月供参考：5307.27 元
💰 支付利息总额：910616.19 元
💰 还款总额：1910616.19 元
==================================================

💡 扩展知识：

• 等额本息是房贷中最常用的还款方式，每月还款金额固定，便于规划家庭支出。
• 如果想增加等额本金还款方式，需要额外计算每月递减的本金和利息，逻辑会更复杂一些------可以作为进阶练习。
• 实际应用中，银行还会收取评估费、保险费等，本案例仅为教学演示。

六、知识补充：输入校验的利器 ------ isdigit() 与 isnumeric()

在实战案例中，我们多次使用了 isdigit() 进行输入校验。这里做一个系统性的对比：

方法	说明	示例	返回值
isdigit()	判断字符串是否只包含数字字符	"123".isdigit()	True
		"12.3".isdigit()	False（小数点不是数字）
		"①②".isdigit()	True（Unicode数字字符也算）
isnumeric()	判断字符串是否只包含数字字符（范围更广）	"一二三".isnumeric()	True
		"123".isnumeric()	True
isdecimal()	判断字符串是否只包含十进制数字（最严格）	"123".isdecimal()	True
		"①②".isdecimal()	False

实际开发建议：

• 输入校验时优先使用 isdigit()，它覆盖了大多数常见场景。
• 如果需要支持负数或小数，需要额外处理：num_str.lstrip('-').replace('.', '', 1).isdigit()。
• 对于更复杂的格式校验（如邮箱、手机号），应使用正则表达式 （re 模块）。

📝 总结与知识点一览表

核心知识点汇总

类别	语法/关键字	核心作用	易错提醒
单分支	if	条件成立时执行代码块	不要漏掉冒号 :
双分支	if-else	条件成立/不成立分别处理	else 不带条件表达式
多分支	if-elif-else	多个条件依次判断	顺序从严格到宽松
条件嵌套	if 中嵌套 if	外层条件满足才判断内层	注意缩进层级
条件循环	while	条件成立时重复执行	防止无限循环
遍历循环	for	遍历可迭代对象	遍历时不要修改原对象
整数序列	range()	生成整数序列	range(5) 生成 0~4，不含5
循环嵌套	循环内套循环	外层每轮，内层全执行	注意内层循环变量的重置
终止循环	break	结束整个循环	只会终止所在层循环
跳过本次	continue	跳过本次循环剩余代码	不会终止循环
循环的 else	while...else / for...else	循环正常结束（未被break打断）时执行	被 break 打断时不执行

常用语法速查

场景	代码模板
单条件判断	if score >= 60: print("及格")
双条件判断	if score >= 60: print("及格") else: print("不及格")
多条件判断	if score >= 90: ... elif score >= 60: ... else: ...
while 循环	i = 0; while i < 10: ...; i += 1
for 循环	for i in range(10): ...
遍历列表	for item in list: ...
跳出循环	break
跳过本次	continue

常见错误排查指南

错误现象	大概率原因	解决方案
IndentationError: expected an indented block	if 或循环后面没有缩进的代码块	在冒号后按 Tab 或 4 空格缩进
IndentationError: unindent does not match	同一代码块的缩进量不一致（Tab与空格混用）	统一使用 4 个空格缩进
SyntaxError: invalid syntax 在 elif 处	elif 前面没有匹配的 if	检查是否把 else if 误写为 elif 但前面没有 if
死循环（程序卡死）	while 条件永远为 True 且没有 break	确保循环变量会变化，或设置退出条件
for 循环中修改列表导致预期外的结果	遍历时删除或添加元素改变了列表长度	遍历副本 for item in list[:]:
break 只跳出一层循环	在嵌套循环中使用 break，内层跳出但外层继续	如需跳出所有循环，可用标志变量或封装为函数后 return

生产/学习最佳实践

1. 条件判断的顺序 ：在 if-elif-else 中，优先判断最严格、最具体的条件，再判断通用条件。如先判断满分（100分），再判断优秀（>=90），最后判断合格（>=60）。
2. 避免过深的嵌套 ：嵌套层级超过 3 层时，代码的可读性会急剧下降。可以考虑将内层逻辑提取为函数，或使用逻辑运算符 and / or 合并条件。
3. 善用 while...else ：当需要区分"循环因条件不满足而正常结束"与"循环被 break 提前终止"时，while...else 比设置标志变量更简洁优雅。
4. 输入校验是专业素养 ：永远不要假设用户的输入是合法的。在实际生产环境中，恶意输入或误操作导致的程序崩溃是绝对不能被容忍的。每次 input() 后都应该进行必要的校验。
5. 循环中尽量少用 break ：过多的 break 会让循环的退出条件变得不清晰。如果可能，尽量在主循环条件中明确退出逻辑。

本期内容到此就告一段落了，如果您在使用过程中发现任何问题或有改进建议，欢迎随时提出！

🔜 下期预告

本期我们系统地学习了Python的流程控制------if 让程序拥有了"判断能力"，while 和 for 让程序拥有了"重复能力"，break 和 continue 则提供了更精细的循环控制粒度。同时，我们通过五个完整的实战项目（计算器、猜数字、逢7拍手、五子棋棋盘、房贷计算器）将这些知识点落到了实处。

下一期，我们将进入 字符串 的专题学习。字符串是编程中最常用的数据类型之一，我们将深入掌握：字符串的创建与转义字符、三种格式化方式（%、format()、f-string）、字符串的查找、替换、分割、拼接、去空格、大小写转换、对齐等常用操作，并通过敏感词替换、文字排版工具等实战项目，将字符串处理技巧应用到实际场景中。敬请期待！

---

--- Compiled and Authored by Whisky --- July 9 th, 2026