核心结论（一句话总结）

continue 语句只会跳出它所在的那一层循环，继续执行该层循环的下一次迭代，它不会影响任何外层循环的执行流程。

continue 在单层循环中的行为

为了更好地理解多层情况,我们先回顾一下 continue 在单层循环中的作用。

# 单层循环中的 continue
for i in range(5):
    if i == 2:
        print("发现 2，使用 continue 跳过本次循环")
        continue  # 跳过本次循环的剩余代码，直接进入 i=3 的迭代
    print(f"当前数字是: {i}")
print("循环结束")

输出:

当前数字是: 0
当前数字是: 1
发现 2，使用 continue 跳过本次循环
当前数字是: 3
当前数字是: 4
循环结束

可以看到,当 i 为 2 时，print("当前数字是: 2") 这行代码被跳过了，循环继续执行下一次迭代。

continue 在多层循环中的行为

我们来看 continue 在 for 循环嵌套 for 循环的情况，关键在于，continue 只影响它直接所在的那个 for 循环。

示例 1：continue 在内层循环

这是一个最常见的场景,我们有一个外层循环和一个内层循环。

# continue 在内层循环中
print("--- 示例 1：continue 在内层循环 ---")
for i in range(3):  # 外层循环
    print(f"\n--- 外层循环开始，i = {i} ---")
    for j in range(3):  # 内层循环
        if j == 1:
            print(f"    内层循环：j 是 1，使用 continue 跳过本次内层循环")
            continue  # 这个 continue 只影响内层 for j 循环
        print(f"    内层循环：j = {j}，正常执行")
    print(f"--- 外层循环结束，i = {i} ---")
print("\n所有循环结束")

输出分析:

1. 当 i = 0 时:

   • 外层循环开始。
   • 内层循环 j 从 0 开始。
   • j=0: 条件不满足，打印 内层循环：j = 0，正常执行。
   • j=1: 条件满足，打印提示信息，continue 跳过内层循环的本次迭代，这意味着 print(f" 内层循环：j = {j}，正常执行") 不会被执行。
   • j=2: 条件不满足，打印 内层循环：j = 2，正常执行。
   • 内层循环结束,外层循环继续。

2. 当 i = 1 和 i = 2 时:

   • 过程与 i = 0 完全相同。

最终输出:

--- 示例 1：continue 在内层循环 ---
--- 外层循环开始，i = 0 ---
    内层循环：j = 0，正常执行
    内层循环：j 是 1，使用 continue 跳过本次内层循环
    内层循环：j = 2，正常执行
--- 外层循环结束，i = 0 ---
--- 外层循环开始，i = 1 ---
    内层循环：j = 0，正常执行
    内层循环：j 是 1，使用 continue 跳过本次内层循环
    内层循环：j = 2，正常执行
--- 外层循环结束，i = 1 ---
--- 外层循环开始，i = 2 ---
    内层循环：j = 0，正常执行
    内层循环：j 是 1，使用 continue 跳过本次内层循环
    内层循环：j = 2，正常执行
--- 外层循环结束，i = 2 ---
所有循环结束

内层的 continue 只跳过了内层循环的某一次迭代，外层循环不受任何影响，继续执行它的下一次迭代。

如何实现“跳出多层循环”？

我们可能会遇到一种需求：在满足某个条件时，希望直接跳出整个嵌套循环结构（比如同时跳出内层和外层循环）。continue 无法做到这一点，因为它只能“向上”跳一层。

要实现“跳出多层循环”，有以下几种常用方法：

使用标志位（Flag）

这是最经典、最通用的方法，我们设置一个布尔变量作为“开关”，当需要跳出时，设置开关为 True，然后在每个循环的判断条件中加入对开关的检查。

# 使用标志位跳出多层循环
print("\n--- 示例 2：使用标志位跳出多层循环 ---")
found = False  # 标志位，初始为 False
for i in range(3):
    if found:
        break  # 如果已经找到，就跳出外层循环
    for j in range(3):
        print(f"检查 i={i}, j={j}")
        if i == 1 and j == 1:
            print("找到目标 (1, 1)! 设置标志位并跳出所有循环。")
            found = True  # 设置标志位
            break  # 先跳出内层循环
        # 模拟一些操作
        print(f"    处理 ({i}, {j})")
print("\n使用标志位跳出循环结束")

输出:

--- 示例 2：使用标志位跳出多层循环 ---
检查 i=0, j=0
    处理 (0, 0)
检查 i=0, j=1
    处理 (0, 1)
检查 i=0, j=2
    处理 (0, 2)
检查 i=1, j=0
    处理 (1, 0)
检查 i=1, j=1
找到目标 (1, 1)! 设置标志位并跳出所有循环。
使用标志位跳出循环结束

在这个例子中,当 i=1, j=1 时，我们设置 found = True 并 break 出内层循环，下一次外层循环开始时，if found: 条件成立，break 出外层循环，整个嵌套结构就此结束。

将循环封装成函数

利用 return 语句的特性，当在函数中执行 return 时，会立即退出整个函数，这是一种非常优雅和 Pythonic 的方式。

# 使用函数和 return 跳出多层循环
print("\n--- 示例 3：使用函数和 return 跳出多层循环 ---")
def search_and_break():
    for i in range(3):
        for j in range(3):
            print(f"检查 i={i}, j={j}")
            if i == 1 and j == 1:
                print("找到目标 (1, 1)! 使用 return 退出函数。")
                return  # return 会立即终止整个函数的执行
            print(f"    处理 ({i}, {j})")
# 调用函数
search_and_break()
print("\n使用函数和 return 跳出循环结束")

输出:

--- 示例 3：使用函数和 return 跳出多层循环 ---
检查 i=0, j=0
    处理 (0, 0)
检查 i=0, j=1
    处理 (0, 1)
检查 i=0, j=2
    处理 (0, 2)
检查 i=1, j=0
    处理 (1, 0)
检查 i=1, j=1
找到目标 (1, 1)! 使用 return 退出函数。
使用函数和 return 跳出循环结束

当 return 语句被执行时，search_and_break 函数立即终止，后续的循环代码自然不会再执行。

使用 try...except... 结构（较少见，但可行）

我们可以构造一个异常,然后在最外层捕获它，以实现跳出。

# 使用 try-except 跳出多层循环
print("\n--- 示例 4：使用 try-except 跳出多层循环 ---")
class BreakOutLoop(Exception):
    """自定义异常，用于跳出循环"""
    pass
try:
    for i in range(3):
        for j in range(3):
            print(f"检查 i={i}, j={j}")
            if i == 1 and j == 1:
                print("找到目标 (1, 1)! 抛出异常跳出所有循环。")
                raise BreakOutLoop  # 抛出自定义异常
            print(f"    处理 ({i}, {j})")
except BreakOutLoop:
    print("\n捕获到 BreakOutLoop 异常，循环已终止。")
print("\n使用 try-except 跳出循环结束")

这种方法比较巧妙,但不如前两种方法直观，通常只在特定场景下使用。

核心要点：

• continue 是“跳过本次”，不是“跳出循环”。
• continue 的作用域仅限于它所在的那个 for 或 while 循环。
• 如果需要跳出多层循环,请优先考虑标志位或函数封装+return的方法。