Python嵌套循环案例如何多层循环

wen python案例 2026-07-01 144

本文目录导读：

Python嵌套循环案例如何多层循环

1️⃣ 基础多层循环结构
2️⃣ 实用案例
3️⃣ 高级技巧
4️⃣ 实际应用场景
5️⃣ 性能优化技巧

我来给你详细讲解Python多层循环的各种案例和技巧。

1️⃣ 基础多层循环结构

双重循环基础

# 2x3的矩阵遍历
for i in range(2):  # 外层：行
    for j in range(3):  # 内层：列
        print(f"({i},{j})", end=" ")
    print()  # 换行
# 输出：(0,0) (0,1) (0,2)
#       (1,0) (1,1) (1,2)

三重循环示例

# 三维坐标遍历
for x in range(2):
    for y in range(2):
        for z in range(2):
            print(f"({x},{y},{z})", end=" ")
        print()
    print("---")

2️⃣ 实用案例

案例1：乘法表（双重循环）

# 打印99乘法表
for i in range(1, 10):
    for j in range(1, i + 1):  # 内层循环范围随外层变化
        print(f"{j}×{i}={i*j:2d}", end="  ")
    print()

案例2：打印菱形（多重循环控制）

def print_diamond(n):
    # 上半部分
    for i in range(n):
        # 打印空格
        for j in range(n - i - 1):
            print(" ", end="")
        # 打印星号
        for k in range(2 * i + 1):
            print("*", end="")
        print()
    # 下半部分
    for i in range(n - 2, -1, -1):
        for j in range(n - i - 1):
            print(" ", end="")
        for k in range(2 * i + 1):
            print("*", end="")
        print()
print_diamond(5)

案例3：矩阵转置（双重循环）

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
rows = len(matrix)
cols = len(matrix[0])
# 转置矩阵
transposed = []
for i in range(cols):  # 外层遍历列
    row = []
    for j in range(rows):  # 内层遍历行
        row.append(matrix[j][i])
    transposed.append(row)
print("原矩阵:", matrix)
print("转置后:", transposed)

3️⃣ 高级技巧

列表推导式中的多层循环

# 双重循环的列表推导式
pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)
# 带条件的双重循环
matrix = [[i*j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)
# 三维列表
cube = [[[i*j*k for k in range(2)] for j in range(2)] for i in range(2)]
print(cube)

使用itertools.product

from itertools import product
# 等价于三层嵌套循环
for x, y, z in product(range(2), range(3), range(2)):
    print(f"({x},{y},{z})", end=" ")

4️⃣ 实际应用场景

场景1：学生成绩统计

# 多个班级、多个学生的成绩统计
classes = ["A班", "B班", "C班"]
students = ["小明", "小红", "小华"]
scores = [
    [[85, 90, 78], [92, 88, 95], [76, 82, 89]],  # A班
    [[79, 85, 92], [88, 90, 86], [91, 87, 93]],  # B班
    [[95, 88, 82], [77, 83, 90], [84, 86, 91]]   # C班
]
for i, class_name in enumerate(classes):
    print(f"\n=== {class_name} ===")
    for j, student in enumerate(students):
        total = sum(scores[i][j])
        avg = total / len(scores[i][j])
        print(f"{student}: 总分={total}, 平均分={avg:.1f}")

场景2：图像处理（像素遍历）

import numpy as np
# 模拟一个5x5的灰度图像
image = np.random.randint(0, 256, (5, 5))
# 应用3x3均值滤波器
def apply_filter(img, kernel_size=3):
    height, width = img.shape
    pad = kernel_size // 2
    result = np.zeros_like(img)
    for i in range(pad, height - pad):
        for j in range(pad, width - pad):
            # 3层循环：遍历邻域
            total = 0
            count = 0
            for ki in range(-pad, pad + 1):
                for kj in range(-pad, pad + 1):
                    total += img[i + ki][j + kj]
                    count += 1
            result[i][j] = total // count
    return result
print("原图：\n", image)
filtered = apply_filter(image)
print("滤波后：\n", filtered)

场景3：递归替代多层循环（N皇后问题）

def solve_n_queens(n):
    def is_safe(board, row, col):
        # 检查列
        for i in range(row):
            if board[i] == col:
                return False
            # 检查对角线
            if abs(board[i] - col) == abs(i - row):
                return False
        return True
    def backtrack(board, row):
        if row == n:
            solutions.append(board[:])
            return
        for col in range(n):  # 这一层相当于内层循环
            if is_safe(board, row, col):
                board[row] = col
                backtrack(board, row + 1)
    solutions = []
    backtrack([-1] * n, 0)
    return solutions
# 4皇后问题
solutions = solve_n_queens(4)
for sol in solutions:
    print(sol)

5️⃣ 性能优化技巧

循环展开和优化

import time
# 不好的方式：频繁计算
def bad_loop(n):
    result = 0
    for i in range(n):
        for j in range(n):
            result += i * j  # 每次计算i*j
# 好的方式：提前计算
def good_loop(n):
    result = 0
    for i in range(n):
        i_times = i  # 提前计算
        for j in range(n):
            result += i_times * j
# 使用局部变量加速
def fast_loop(n):
    result = 0
    local_range = range  # 局部变量引用
    for i in local_range(n):
        for j in local_range(n):
            result += i * j
# 测试性能
n = 500
start = time.time()
bad_loop(n)
print(f"坏方法: {time.time() - start:.3f}s")
start = time.time()
good_loop(n)
print(f"好方法: {time.time() - start:.3f}s")

使用break和continue控制流程

# 提前跳出多层循环
found = False
for i in range(10):
    for j in range(10):
        if i * j == 42:
            print(f"找到{i}×{j}=42")
            found = True
            break
    if found:
        break
# 或者使用else子句
for i in range(10):
    for j in range(10):
        if i * j == 42:
            print(f"找到{i}×{j}=42")
            break
    else:
        continue  # 内层未找到，继续外层
    break  # 内层找到，跳出外层

多层循环的关键点：