来源：03_循环 hm_10~hm_12 + 网络资料整理

一、详细讲解

1.1 核心概念

嵌套循环与图案打印是Python编程中用于处理二维结构数据的重要知识点。在本课程的第9天，我们将学习循环嵌套的基础概念、九九乘法表的实现、以及各种图案的打印技巧。

嵌套循环是指一个循环内部包含另一个循环的结构。外层循环控制行或外层维度的变化，内层循环控制列或内层维度的变化。通过合理使用嵌套循环，我们可以打印各种规则或不规则的图案，处理矩阵数据，以及解决需要多层迭代的问题。

1.2 嵌套循环基础

1.2.1 嵌套循环的执行原理

# 嵌套循环的基本结构
for i in range(外层次数):    # 外层循环
    for j in range(内层次数):  # 内层循环
        # 内层循环体
    # 外层循环体（内层循环结束后执行）

1.2.2 执行次数计算

# 嵌套循环总执行次数 = 外层次数 × 内层次数
print("=== 嵌套循环执行次数 ===")
outer_times = 3
inner_times = 4
total_executions = outer_times * inner_times
print(f"外层循环 {outer_times} 次 × 内层循环 {inner_times} 次 = 总执行 {total_executions} 次")

# 演示
count = 0
for i in range(3):
    for j in range(4):
        count += 1
        print(f"i={i}, j={j}", end="  ")
    print()  # 内层循环结束后换行
print(f"\n实际执行次数: {count}")

输出：

=== 嵌套循环执行次数 === 外层循环 3 次 × 内层循环 4 次 = 总执行 12 次 i=0, j=0 i=0, j=1 i=0, j=2 i=0, j=3 i=1, j=0 i=1, j=1 i=1, j=2 i=1, j=3 i=2, j=0 i=2, j=1 i=2, j=2 i=2, j=3 实际执行次数: 12

1.3 九九乘法表

1.3.1 标准九九乘法表

# 打印标准九九乘法表
print("=== 九九乘法表 ===")
for i in range(1, 10):      # 外层循环：被乘数 1~9
    for j in range(1, i + 1):  # 内层循环：乘数 1~i
        product = i * j
        print(f"{j}×{i}={product}", end="\t")
    print()  # 换行

输出：

=== 九九乘法表 === 1×1=1 2×1=2 2×2=4 3×1=3 2×3=6 3×3=9 4×1=4 2×4=8 3×4=12 4×4=16 5×1=5 2×5=10 3×5=15 4×5=20 5×5=25 6×1=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36 7×1=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49 8×1=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64 9×1=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

1.3.2 下三角九九乘法表

# 打印下三角九九乘法表
print("=== 下三角九九乘法表 ===")
for i in range(1, 10):
    for j in range(1, 10):
        if j <= i:  # 只打印下三角部分
            print(f"{j}×{i}={i*j}", end="\t")
    print()

1.3.3 带格式的九九乘法表

# 带对齐格式的九九乘法表
print("=== 格式化九九乘法表 ===")
for i in range(1, 10):
    line = ""
    for j in range(1, i + 1):
        line += f"{j}×{i}={i*j:2d}  "
    print(line)

1.4 常见图案打印

1.4.1 正方形图案

# 实心正方形
n = 5
print("=== 实心正方形 ===")
for i in range(n):
    for j in range(n):
        print("█", end=" ")
    print()

print()

# 空心正方形
print("=== 空心正方形 ===")
for i in range(n):
    for j in range(n):
        if i == 0 or i == n - 1 or j == 0 or j == n - 1:
            print("█", end=" ")
        else:
            print(" ", end=" ")
    print()

输出：

=== 实心正方形 === █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ === 空心正方形 === █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █

1.4.2 三角形图案

# 直角三角形（左下角）
n = 5
print("=== 直角三角形（左下角）===")
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print("█", end=" ")
    print()

print()

# 直角三角形（右下角）
print("=== 直角三角形（右下角）===")
for i in range(1, n + 1):
    # 先打印空格
    for j in range(1, n - i + 1):
        print(" ", end=" ")
    # 再打印星号
    for j in range(1, i + 1):
        print("█", end=" ")
    print()

print()

# 等腰三角形
print("=== 等腰三角形 ===")
for i in range(1, n + 1):
    # 打印空格
    for j in range(1, n - i + 1):
        print(" ", end=" ")
    # 打印星号
    for j in range(1, 2 * i):
        print("█", end="")
    print()

输出：

=== 直角三角形（左下角）=== █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ === 直角三角形（右下角）=== █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ === 等腰三角形 === █ ███ █████ ███████ █████████

1.4.3 菱形图案

# 菱形
n = 5
print("=== 菱形 ===")

# 上半部分（包括中间行）
for i in range(1, n + 1):
    # 打印空格
    for j in range(1, n - i + 1):
        print(" ", end="")
    # 打印星号
    for j in range(1, 2 * i):
        print("█", end="")
    print()

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

1.4.4 数字三角形

# 数字三角形
n = 5
print("=== 数字三角形 ===")
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

print()

# 数字菱形
print("=== 数字菱形 ===")
for i in range(1, n + 1):
    # 打印空格
    for j in range(1, n - i + 1):
        print(" ", end=" ")
    # 打印数字
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

for i in range(n - 1, 0, -1):
    # 打印空格
    for j in range(1, n - i + 1):
        print(" ", end=" ")
    # 打印数字
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

1.5 矩阵操作

1.5.1 矩阵遍历

# 定义一个3x4矩阵
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

# 按行遍历
print("=== 按行遍历 ===")
for row in matrix:
    for element in row:
        print(f"{element:3d}", end=" ")
    print()

# 带索引遍历
print("\n=== 带索引遍历 ===")
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"matrix[{i}][{j}] = {matrix[i][j]}")

1.5.2 矩阵转置

# 矩阵转置
matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

rows = len(matrix)
cols = len(matrix[0])

# 创建转置矩阵
transposed = []
for j in range(cols):
    new_row = []
    for i in range(rows):
        new_row.append(matrix[i][j])
    transposed.append(new_row)

print("=== 矩阵转置 ===")
print("原矩阵:")
for row in matrix:
    print(row)

print("\n转置后:")
for row in transposed:
    print(row)

1.6 实用示例

1.6.1 查找质数（埃拉托斯特尼筛法）

# 查找n以内的所有质数
def find_primes(n):
    # 初始化：假设所有数都是质数
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    
    # 筛选
    for i in range(2, int(n ** 0.5) + 1):
        if is_prime[i]:
            # 将i的倍数标记为非质数
            for j in range(i * i, n + 1, i):
                is_prime[j] = False
    
    # 收集结果
    return [i for i in range(2, n + 1) if is_prime[i]]

primes = find_primes(100)
print(f"100以内的质数: {primes}")
print(f"共 {len(primes)} 个")

1.6.2 杨辉三角

# 打印杨辉三角
def print_pascal_triangle(n):
    triangle = []
    for i in range(n):
        row = [1] * (i + 1)
        for j in range(1, i):
            row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
        triangle.append(row)
    
    # 打印
    for row in triangle:
        # 前面加空格对齐
        print(" " * (n - len(row)) * 2, end="")
        for num in row:
            print(f"{num:4d}", end="")
        print()

print_pascal_triangle(8)

1.6.3 迷宫模拟

# 简单的迷宫遍历
maze = [
    [1, 1, 1, 1, 1],
    [0, 0, 0, 0, 1],
    [1, 1, 1, 0, 1],
    [1, 0, 0, 0, 0],
    [1, 1, 1, 1, 1]
]

def find_path(maze, start, end):
    """简单的迷宫求解（只演示嵌套循环遍历）"""
    rows = len(maze)
    cols = len(maze[0])
    
    # 尝试从起点走到终点
    for i in range(rows):
        for j in range(cols):
            if i == start[0] and j == start[1]:
                print(f"起点: ({i}, {j})")
            if maze[i][j] == 0:  # 可通行的路
                print(f"探索: ({i}, {j})")

find_path(maze, (1, 0), (4, 3))

1.7 嵌套循环的性能优化

1.7.1 减少计算量

# 低效：每次都计算长度
data = list(range(1000))
for i in range(len(data)):
    for j in range(len(data)):
        pass  # 大量重复计算

# 高效：预先计算长度
n = len(data)
for i in range(n):
    for j in range(n):
        pass  # 避免重复计算

1.7.2 使用列表推导式替代

# 嵌套循环构建矩阵
rows, cols = 3, 4

# 嵌套循环
matrix = []
for i in range(rows):
    row = []
    for j in range(cols):
        row.append(i * cols + j)
    matrix.append(row)

# 列表推导式（更高效）
matrix = [[i * cols + j for j in range(cols)] for i in range(rows)]

print("矩阵:")
for row in matrix:
    print(row)

1.8 常见错误与调试

# 错误1：缩进错误导致逻辑混乱
# for i in range(3):
# for j in range(3):  # 缩进不正确！
#     print(i, j)

# 错误2：循环变量使用错误
# for i in range(3):
#     for i in range(3):  # 覆盖了外层变量
#         print(i, j)

# 正确做法：使用不同的变量名
for i in range(3):
    for j in range(3):
        print(f"i={i}, j={j}")

# 错误3：在内层循环中修改外层循环变量
# for i in range(3):
#     for j in range(3):
#         i = 10  # 不要这样做！

二、背诵版

Day9 要点速记： 【嵌套循环执行次数】 总次数 = 外层次数 × 内层次数 【九九乘法表】 外层: range(1, 10) # 被乘数 1~9 内层: range(1, i+1) # 乘数 1~当前被乘数 print(end='\t') # 制表符分隔 print() # 换行 【图案打印关键】 - 外层循环：控制行数 - 内层循环：控制每行的内容 - print(end=' ') 控制不换行 - 空格数量决定图案形状 【常见图案】 - 正方形：n×n - 三角形：每行递减/递增 - 菱形：上下对称

三、考前记忆

要素 内容
今日主题 嵌套循环与图案打印
关键词 循环嵌套、九九乘法表、图案
执行次数 外层次数 × 内层次数
外层控制 行数/外层维度
内层控制 每行的列数/内层维度
重要考点 嵌套循环执行次数计算、图案分析

四、测试题

1. 单选题： 嵌套循环，外层执行3次，内层执行4次，总执行次数是多少？

  • A. 3次
  • B. 4次
  • C. 7次
  • D. 12次

2. 单选题： 以下代码的输出是什么？

for i in range(1, 4):
    for j in range(1, i + 1):
        print("*", end="")
    print()
  • A. *** *** ***
  • B. * ** ***
  • C. * * * *
  • D. 编译错误

3. 填空题： 打印九九乘法表时，外层循环控制 _______（填"被乘数"或"乘数"）。

4. 填空题： 要打印一个5行的直角三角形，第i行需要打印 _______ 个星号。

5. 简答题： 请描述嵌套循环的执行原理，并说明如何计算总执行次数。

6. 代码题： 使用嵌套循环打印以下图案：

* ** *** ****

7. 代码题： 使用嵌套循环打印九九乘法表的第一行到第五行。

8. 代码题： 打印一个5x5的空心正方形。

9. 综合题： 设计一个程序，输入一个数字n，打印n行的金字塔图案。

  1. D - 总次数 = 外层次数 × 内层次数 = 3 × 4 = 12次

  2. B - i=1时打印1个*，i=2时打印2个*，i=3时打印3个*，输出 * ** ***

  3. 被乘数 - 外层循环控制1~9的被乘数

  4. i - 第i行打印i个星号

嵌套循环执行原理： - 外层循环第一次迭代时，内层循环完整执行所有次数 - 外层循环第二次迭代时，内层循环再次完整执行所有次数 - 以此类推，直到外层循环结束 总执行次数 = 外层循环次数 × 内层循环次数 例如：外层3次，内层4次，总共执行 3×4=12 次
n = 4
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print("*", end="")
    print()

for i in range(1, 6):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()

n = 5
for i in range(n):
    for j in range(n):
        if i == 0 or i == n - 1 or j == 0 or j == n - 1:
            print("█", end=" ")
        else:
            print(" ", end=" ")
    print()

def print_pyramid(n):
    for i in range(1, n + 1):
        # 打印空格
        for j in range(1, n - i + 1):
            print(" ", end="")
        # 打印星号
        for j in range(1, 2 * i):
            print("█", end="")
        print()

n = int(input("输入金字塔行数: "))
print_pyramid(n)

五、扩展阅读

5.1 多层嵌套循环

# 三层嵌套循环
for i in range(2):
    for j in range(2):
        for k in range(2):
            print(f"({i}, {j}, {k})")

5.2 动态图案生成

# 根据用户输入生成不同的图案
def print_pattern(n, pattern_type):
    if pattern_type == "triangle":
        for i in range(1, n + 1):
            print("*" * i)
    elif pattern_type == "inverted_triangle":
        for i in range(n, 0, -1):
            print("*" * i)
    elif pattern_type == "diamond":
        for i in range(1, n + 1):
            print(" " * (n - i) + "*" * (2 * i - 1))
        for i in range(n - 1, 0, -1):
            print(" " * (n - i) + "*" * (2 * i - 1))

print_pattern(5, "diamond")

5.3 二维数组操作技巧

# 创建二维数组
rows, cols = 3, 4
matrix = [[0] * cols for _ in range(rows)]

# 填充
for i in range(rows):
    for j in range(cols):
        matrix[i][j] = i * cols + j + 1

# 打印
for row in matrix:
    print(" ".join(f"{x:2d}" for x in row))

# 对角线元素
print("\n主对角线:", [matrix[i][i] for i in range(min(rows, cols))])

恭喜完成Day9学习！明天我们将学习函数定义与调用，掌握代码封装和复用的基本技能。