Python 循环嵌套详解
循环嵌套指一个循环内部包含另一个循环，Python 中支持 for 与 for、for 与 while、while 与 while 任意组合的嵌套，核心是「外层循环执行 1 次，内层循环完整执行一轮」。
一、核心逻辑：嵌套循环的执行流程
以「外层 for + 内层 for」为例，执行步骤：
- 外层循环取第一个元素；
- 内层循环从头执行到尾（所有元素）；
- 外层循环取第二个元素；
- 内层循环再次从头执行到尾；
- 重复直到外层循环结束。
可视化示例：
python
运行
# 外层循环：2次（1、2），内层循环：3次（a、b、c）
for i in [1, 2]:
print(f"外层循环：i = {i}")
for j in ['a', 'b', 'c']:
print(f" 内层循环：j = {j}")
输出结果（清晰体现执行顺序）：
plaintext
外层循环：i = 1
内层循环：j = a
内层循环：j = b
内层循环：j = c
外层循环：i = 2
内层循环：j = a
内层循环：j = b
内层循环：j = c
二、常见嵌套循环类型
1. for-for 嵌套（最常用）
适用于遍历「二维结构」（如二维列表、矩阵）、生成组合数据等场景。
场景 1：遍历二维列表（矩阵）
python
运行
# 3行2列的矩阵
matrix = [
[1, 2],
[3, 4],
[5, 6]
]
# 外层遍历行，内层遍历列
for row in matrix:
for num in row:
print(num, end=' ')
print() # 每行结束换行
输出：
plaintext
1 2
3 4
5 6
场景 2：打印乘法口诀表（经典案例）
python
运行
# 外层控制行数（1-9），内层控制列数（1-当前行数）
for i in range(1, 10):
for j in range(1, i+1):
print(f"{j}×{i}={i*j}", end='\t')
print() # 每行结束换行
输出（简洁排版的乘法表）：
plaintext
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
...
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
2. for-while 嵌套
外层用 for 遍历可迭代对象，内层用 while 实现条件循环。
示例：为每个列表元素执行指定次数的操作
python
运行
# 列表元素：[数值, 执行次数]
tasks = [(2, 3), (5, 2), (8, 1)]
for num, count in tasks:
print(f"处理数值 {num}，执行 {count} 次：")
# 内层while循环控制执行次数
i = 0
while i < count:
print(f" 操作{i+1}：{num} × 2 = {num*2}")
i += 1
输出：
plaintext
处理数值 2，执行 3 次：
操作1：2 × 2 = 4
操作2：2 × 2 = 4
操作3：2 × 2 = 4
处理数值 5，执行 2 次：
操作1：5 × 2 = 10
操作2：5 × 2 = 10
处理数值 8，执行 1 次：
操作1：8 × 2 = 16
3. while-while 嵌套
双层条件循环，需注意设置终止条件，避免无限循环。
示例：打印直角三角形（用 while 嵌套）
python
运行
# 外层控制行数（1-5）
row = 1
while row <= 5:
# 内层控制每行的*数量（等于当前行数）
col = 1
while col <= row:
print('*', end='')
col += 1
print() # 换行
row += 1
输出：
plaintext
*
**
***
****
*****
三、嵌套循环的控制：break/continue
break 和 continue 仅作用于当前所在的循环层，需结合标志位实现「跳出多层循环」。
1. 单层控制（仅影响内层 / 外层）
python
运行
# 示例：内层循环遇到3则终止，外层继续
for i in range(1, 4):
print(f"外层：i={i}")
for j in range(1, 6):
if j == 3:
break # 仅终止内层循环
print(f" 内层：j={j}")
输出（内层循环到 3 就停，外层正常执行）：
plaintext
外层：i=1
内层：j=1
内层：j=2
外层：i=2
内层：j=1
内层：j=2
外层：i=3
内层：j=1
内层：j=2
2. 跳出多层循环（3 种方法）
方法 1：使用标志位（推荐，可读性高）
python
运行
flag = False # 标志位：是否需要终止所有循环
for i in range(1, 4):
for j in range(1, 6):
if i == 2 and j == 3:
flag = True
break # 先终止内层
if flag:
break # 再终止外层
print(f"外层执行：i={i}")
print("循环结束")
输出（i=2、j=3 时终止所有循环）：
plaintext
外层执行：i=1
循环结束
方法 2：使用异常捕获
python
运行
try:
for i in range(1, 4):
for j in range(1, 6):
if i == 2 and j == 3:
raise StopIteration # 抛出异常终止循环
print(f"外层执行：i={i}")
except StopIteration:
print("循环结束")
方法 3：使用函数 return（循环在函数内）
python
运行
def nested_loop():
for i in range(1, 4):
for j in range(1, 6):
if i == 2 and j == 3:
return # 函数返回，直接终止所有循环
print(f"外层执行：i={i}")
print("循环结束")
nested_loop()
四、嵌套循环的性能优化
嵌套循环的时间复杂度通常是 O (n*m)（外层 n 次，内层 m 次），数据量大时需优化：
1. 减少内层循环的计算量
将内层循环的重复计算提到外层：
python
运行
# 低效：内层每次都计算len(words)
words = ["apple", "banana", "cherry"]
for i in range(3):
for j in range(len(words)):
print(words[j])
# 高效：提前计算长度，避免重复计算
words_len = len(words)
for i in range(3):
for j in range(words_len):
print(words[j])
2. 尽早终止不必要的循环
用 if 判断提前跳出，减少循环次数：
python
运行
# 示例：查找列表中是否存在和为10的两个数
nums = [1, 3, 5, 7, 9]
found = False
for i in range(len(nums)):
for j in range(i+1, len(nums)):
if nums[i] + nums[j] == 10:
print(f"找到：{nums[i]} + {nums[j]} = 10")
found = True
break
if found:
break
3. 用列表推导式 / 内置函数替代嵌套循环（简洁 + 高效）
列表推导式的底层是 C 实现，比纯 Python 嵌套循环快：
python
运行
# 需求：生成1-3和1-2的所有组合（(1,1),(1,2),(2,1),(2,2),(3,1),(3,2)）
# 低效：嵌套for+append
combinations = []
for i in range(1, 4):
for j in range(1, 3):
combinations.append((i, j))
# 高效：列表推导式
combinations = [(i, j) for i in range(1, 4) for j in range(1, 3)]
五、常见应用场景
- 数据处理：遍历二维表格、嵌套字典；
- 算法实现：排序（冒泡 / 选择排序）、查找（二维数组查找）；
- 图形打印：三角形、矩形、菱形等图案；
- 组合生成：生成多组数据的笛卡尔积（如颜色 + 尺寸组合）。
示例：冒泡排序（嵌套循环实现）
python
运行
nums = [5, 2, 9, 1, 5, 6]
n = len(nums)
# 外层：控制排序轮数（n-1轮）
for i in range(n-1):
# 内层：每轮比较相邻元素，逐步将最大值移到末尾
for j in range(n-1-i):
if nums[j] > nums[j+1]:
nums[j], nums[j+1] = nums[j+1], nums[j]
print("排序结果：", nums) # [1, 2, 5, 5, 6, 9]
总结
- 嵌套循环的核心是「外层 1 次，内层一轮」，执行顺序需重点理解；
break/continue仅作用于当前循环层，多层终止需用标志位 / 异常 /return；- 性能优化优先减少内层计算、尽早终止循环，或用列表推导式替代；
- 经典场景（乘法表、冒泡排序、二维列表遍历）需熟练掌握。
