如何在Python中使用循环嵌套？-CFANZ编程社区

在Python里，循环嵌套指的是在一个循环内部放置另一个循环。借助这种方式，你能够处理多维数据结构，像嵌套列表、矩阵等，也可以执行需要多次迭代的复杂操作。下面为你详细介绍循环嵌套的使用方法和常见场景。

一、嵌套循环的基本语法

1. for循环嵌套

for 变量1 in 可迭代对象1:
    # 外层循环体
    for 变量2 in 可迭代对象2:
        # 内层循环体
        执行语句

2. while循环嵌套

while 条件1:
    # 外层循环体
    while 条件2:
        # 内层循环体
        执行语句

3. 混合嵌套

for 变量 in 可迭代对象:
    # 外层循环体
    while 条件:
        # 内层循环体
        执行语句

二、嵌套循环的执行流程

嵌套循环的执行逻辑是：外层循环每执行一次，内层循环会完整执行一轮。下面通过具体例子来说明：

for i in range(2):  # 外层循环2次
    print(f"外层循环: {i}")
    for j in range(3):  # 内层循环3次
        print(f"  内层循环: {j}")

# 输出结果：
# 外层循环: 0
#   内层循环: 0
#   内层循环: 1
#   内层循环: 2
# 外层循环: 1
#   内层循环: 0
#   内层循环: 1
#   内层循环: 2

三、嵌套循环的常见应用场景

1. 处理嵌套数据结构

例如，遍历二维列表（矩阵）：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for element in row:
        print(element, end=" ")
    print()  # 换行

# 输出结果：
# 1 2 3 
# 4 5 6 
# 7 8 9

2. 生成笛卡尔积

colors = ["红", "绿", "蓝"]
sizes = ["S", "M", "L"]

for color in colors:
    for size in sizes:
        print(f"{color}色 {size}码")

# 输出结果：
# 红色 S码
# 红色 M码
# 红色 L码
# 绿色 S码
# 绿色 M码
# 绿色 L码
# 蓝色 S码
# 蓝色 M码
# 蓝色 L码

3. 实现冒泡排序算法

冒泡排序需要两层循环：

numbers = [5, 3, 8, 4, 6]

for i in range(len(numbers) - 1):  # 外层循环控制轮数
    for j in range(len(numbers) - 1 - i):  # 内层循环比较元素
        if numbers[j] > numbers[j + 1]:
            # 交换元素
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

print(numbers)  # 输出：[3, 4, 5, 6, 8]

四、嵌套循环中的控制语句

你可以使用 break 和 continue 来控制嵌套循环的执行：

break：终止当前所在的循环。
continue：跳过当前循环的剩余部分，直接进入下一次循环。

for i in range(3):
    print(f"外层循环: {i}")
    for j in range(3):
        if j == 1:
            break  # 只终止内层循环的当前迭代
        print(f"  内层循环: {j}")

# 输出结果：
# 外层循环: 0
#   内层循环: 0
# 外层循环: 1
#   内层循环: 0
# 外层循环: 2
#   内层循环: 0

如果想从多层嵌套循环中直接跳出，可以使用标志变量或者将循环封装成函数并使用 return：

found = False
for i in range(3):
    for j in range(3):
        if i == 1 and j == 1:
            found = True
            break  # 跳出内层循环
    if found:
        break  # 跳出外层循环

print(f"找到位置: {found}")  # 输出：找到位置: True

五、实战案例：打印九九乘法表

for i in range(1, 10):  # 外层循环控制行数（1-9）
    for j in range(1, i + 1):  # 内层循环控制列数（每行递增）
        print(f"{j}×{i}={i*j}\t", end="")
    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

六、性能注意事项

嵌套循环会显著增加时间复杂度。例如，两层嵌套的 for 循环时间复杂度是 O(n²)，处理大量数据时可能会导致性能问题。在这种情况下，你可以考虑以下优化方法：

减少不必要的内层循环计算。
使用生成器表达式或列表推导式替代某些嵌套循环。
利用 NumPy 等库进行向量化操作。

合理运用嵌套循环，能够高效地处理复杂问题。不过，为了保证代码的可读性，嵌套层级最好不要超过 3 层。