程序员scholar
scholar
2025-07-20
目录

while循环

# while 循环

与 for 循环遍历数据集合不同，while 循环的核心在于基于条件的重复。只要指定的条件保持为 True，while 循环就会不知疲倦地一直执行下去，直到条件变为 False。这使它成为处理未知迭代次数场景的完美工具。

# 1. while 循环的基本语法

while 循环的结构非常直观：它包含一个循环条件和一个当条件为真时执行的代码块。

  • 语法结构：

    while condition:
    # 条件为 True 时，重复执行这里的代码
    # !! 必须在这里包含能最终让 condition 变为 False 的逻辑
    ...
    1
    2
    3
    4

  • 一个关键组成部分：循环变量 通常，我们需要一个“循环变量”来控制条件。这个变量必须在循环内部被更新，否则条件将永远为 True，导致无限循环。

  • 示例：简单的计数器

    count = 1 # 1. 初始化循环变量
while count <= 5: # 2. 设置循环条件
    print(f"当前计数是: {count}")
    count += 1 # 3. 在循环体内更新循环变量，至关重要！

print("循环结束。")
# 输出:
# 当前计数是: 1
# 当前计数是: 2
# 当前计数是: 3
# 当前计数是: 4
# 当前计数是: 5
# 循环结束。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

# 2. 循环控制：break 与 continue

break 和 continue 为 while 循环提供了更精细的流程控制能力。

# 2.1 break：立即终止循环

当程序在循环中遇到 break 语句时，它会立即完全终止当前的 while 循环，无论循环条件是否仍然为 True。

# 场景：从1数到10，但如果数到3就提前停止
i = 1
while i <= 10:
    print(f"正在数: {i}")
    if i == 3:
        print("数到3，提前结束！")
        break # 立即跳出循环
    i += 1

print("程序退出循环。")
# 输出:
# 正在数: 1
# 正在数: 2
# 正在数: 3
# 数到3，提前结束！
# 程序退出循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 2.2 continue：跳过当前迭代

当程序在循环中遇到 continue 语句时，它会跳过当前这一轮循环的剩余部分，直接回到循环顶部的条件判断处，开始下一轮迭代。

# 场景：打印1到5之间的数字，但跳过3
i = 0
while i < 5:
    i += 1
    if i == 3:
        print("遇到3，跳过本次打印...")
        continue # 跳过下面的 print 语句，直接开始下一次循环
    print(f"当前数字是: {i}")
# 输出:
# 当前数字是: 1
# 当前数字是: 2
# 遇到3，跳过本次打印...
# 当前数字是: 4
# 当前数字是: 5
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 3. 无限循环 (while True)：构建持续运行的程序

while True: 是一种非常常见的编程模式，它会创建一个无限循环。这种循环自身永远不会结束，必须依赖内部的 if 条件和 break 语句来提供退出路径。

  • 常见用途：

    • 用户输入验证：反复请求用户输入，直到输入有效为止。
    • 菜单驱动程序：让用户可以反复选择不同的功能。
    • 服务器或游戏主循环：需要持续监听事件或更新状态。

  • 示例：简单的命令行工具

    while True:
    command = input("请输入命令 (输入 'quit' 退出): ")
    if command == "quit":
        print("正在退出程序...")
        break
    elif command == "help":
        print("可用命令: help, quit, status")
    elif command == "status":
        print("系统状态: 正常")
    else:
        print(f"错误: 未知命令 '{command}'")

# 示例交互:
# 请输入命令 (输入 'quit' 退出): status
# 系统状态: 正常
# 请输入命令 (输入 'quit' 退出): quit
# 正在退出程序...
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

# 4. while-else 语句：循环正常结束的标志

while 循环也可以带有一个 else 子句。这个 else 块的执行时机非常特殊：它只在 while 循环正常、完整地执行完毕（即循环条件自然变为 False，而不是被 break 语句中断）后才会执行。

  • 场景1：循环正常结束，else 执行

    count = 1
while count <= 3:
    print(f"执行第 {count} 次循环。")
    count += 1
else:
    print("循环条件变为False，正常结束，因此执行 else 块。")
# 输出:
# 执行第 1 次循环。
# 执行第 2 次循环。
# 执行第 3 次循环。
# 循环条件变为False，正常结束，因此执行 else 块。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

  • 场景2：循环被 break 中断，else 不执行

    count = 1
while count <= 5:
    if count == 3:
        print("在 count=3 时被 break 中断。")
        break
    print(f"执行第 {count} 次循环。")
    count += 1
else:
    print("这个 else 块将不会被执行。")
# 输出:
# 执行第 1 次循环。
# 执行第 2 次循环。
# 在 count=3 时被 break 中断。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

# 5. 嵌套 while 循环

while 循环内部可以包含另一个 while 循环，形成嵌套结构，用于处理更复杂的、有层次的重复逻辑。

outer_count = 1
while outer_count <= 2:
    print(f"--- 外层循环第 {outer_count} 次开始 ---")
    inner_count = 1
    while inner_count <= 3:
        print(f"  内层循环: {inner_count}")
        inner_count += 1
    print(f"--- 外层循环第 {outer_count} 次结束 ---\n")
    outer_count += 1
# 输出:
# --- 外层循环第 1 次开始 ---
#   内层循环: 1
#   内层循环: 2
#   内层循环: 3
# --- 外层循环第 1 次结束 ---
#
# --- 外层循环第 2 次开始 ---
#   内层循环: 1
#   内层循环: 2
#   内层循环: 3
# --- 外层循环第 2 次结束 ---
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 6. for 循环 vs. while 循环：如何选择？

特性 for 循环 (迭代循环) while 循环 (条件循环)
核心思想 遍历一个已知的序列或集合 重复直到某个条件不再满足
适用场景 迭代次数已知或需要处理序列中的每项 迭代次数未知，依赖动态变化的条件
语法 for item in iterable: while condition:
易用性 简洁，不易出错，自动处理迭代 需手动管理循环变量，要警惕死循环

# 场景对比1：遍历列表

  • for 循环 (首选)：代码更简洁、更 Pythonic、不易出错。

    fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
    1
    2
    3

  • while 循环 (也能实现，但更繁琐)：需要手动创建索引、判断边界和更新索引。

    fruits = ["apple", "banana", "cherry"]
i = 0
while i < len(fruits):
    print(fruits[i])
    i += 1
    1
    2
    3
    4
    5

# 场景对比2：等待用户特定输入

  • while 循环 (首选)：完美匹配“直到...为止”的逻辑。

    while True:
    response = input("你同意这些条款吗? (yes/no): ")
    if response.lower() == 'yes':
        print("感谢您的同意！")
        break
    1
    2
    3
    4
    5

  • for 循环 (不适用)：for 循环需要一个可迭代对象，不适合这种条件驱动的场景。

决策指南：

  • 如果你的问题可以描述为“为集合中的每一个元素做某事”，请使用 for 循环。
  • 如果你的问题可以描述为“只要某个条件还成立，就一直做某事”，请使用 while 循环。

# 7. 最佳实践与常见陷阱

  1. 陷阱1：无限循环 (死循环) 这是 while 循环最常见的错误。务必确保循环体内有代码能最终让循环条件变为 False。

    # 错误的例子：忘记更新循环变量
i = 0
while i < 5:
    print("这会永远打印下去！")
    # 缺少 i += 1
    1
    2
    3
    4
    5

  2. 陷阱2：“差一错误” (Off-by-One Error) 在使用计数器时，要特别注意循环的边界条件是 < 还是 <=，这会决定循环多执行或少执行一次。

  3. 实践1：优先使用 for 循环 对于遍历列表、字符串等序列的场景，for 循环总是比 while 循环更清晰、更安全的选择。

  4. 实践2：保持循环体简洁 如果 while 循环的内部逻辑变得非常复杂，可以考虑将其中的一部分提取出来，封装成一个函数，以提高代码的可读性。

编辑此页 (opens new window)
上次更新: 2025/07/23, 06:33:16
for循环
循环综合练习

← 循环综合练习→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar