Python for 循环详解与实战案例

遍历字典

person = {"name": "张三", "age": 30, "city": "北京"}
# 遍历键（默认）
for key in person:
    print(key)
# 输出：name age city
# 遍历值
for value in person.values():
    print(value)
# 输出：张三 30 北京
# 同时遍历键和值
for key, value in person.items():
    print(f"{key}: {value}")

使用 range() 生成数字序列

# 生成 0 到 4
for i in range(5):
    print(i, end=" ")
# 输出：0 1 2 3 4
# 生成 2 到 8，步长为 2
for i in range(2, 9, 2):
    print(i, end=" ")
# 输出：2 4 6 8
# 使用索引遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for i in range(len(fruits)):
    print(f"索引 {i}: {fruits[i]}")

使用 enumerate() 同时获取索引和元素

fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
    print(f"索引 {index}: {fruit}")

使用 zip() 并行遍历多个可迭代对象

names = ["张三", "李四", "王五"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name} 的分数是 {score}")

循环控制：break 和 continue

# 查找第一个偶数
numbers = [1, 3, 5, 8, 9, 10]
for num in numbers:
    if num % 2 == 0:
        print(f"找到偶数：{num}")
        break  # 立即退出循环
# 跳过偶数，打印奇数
for num in numbers:
    if num % 2 == 0:
        continue  # 跳过本次循环剩余部分
    print(num)

for...else 结构

# 检查列表中是否有偶数
numbers = [1, 3, 5, 7, 9]
for num in numbers:
    if num % 2 == 0:
        print("发现偶数！")
        break
else:
    print("没有偶数。")  # 因为循环未被 break，所以执行

列表推导式（简洁的 for 循环）

# 生成 0~9 的平方列表
squares = [x**2 for x in range(10)]
print(squares)
# 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 带条件的推导式（只保留偶数）
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)
# 输出：[0, 4, 16, 36, 64]

遍历文件对象

with open("example.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line, end="")  # 逐行打印

2. 案例一：打印杨辉三角（数字金字塔）

杨辉三角（Pascal's Triangle）是一个经典的数学图形，每一行由组合数构成，满足：

• 第 n 行有 n+1 个数字（行号从 0 开始）。
• 首尾数字为 1。
• 内部数字等于上一行相邻两数之和：triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j]。

2.1 使用组合数公式（math.comb）

import math

def print_pascal_comb(n):
    """打印 n 行的杨辉三角，使用组合数公式"""
    for row in range(n):
        # 打印前导空格，使三角形居中
        print(" " * (n - row - 1) * 3, end="")
        # 每个数字占 3 位，乘 3 对齐
        for col in range(row + 1):
            num = math.comb(row, col)
            print(f"{num:3}", end=" ")
        print()

print_pascal_comb(6)

输出：

  1
  1 1
 1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

for 循环点睛：

• 外层 for row 控制行数。
• 内层 for col 遍历每一行的元素，用组合数计算值。
• 前导空格数量随行数递减，实现居中效果。

2.2 使用迭代生成（递推关系）

def print_pascal_iter(rows):
    """打印 rows 行的杨辉三角，使用迭代生成"""
    triangle = []  # 存储整个三角形
    for i in range(rows):
        row = [1] * (i + 1)  # 初始化为全 1，首尾已正确
        for j in range(1, i):
            # 从第 2 个到倒数第 2 个
            row[j] = triangle[i-1][j-1] + triangle[i-1][j]
        triangle.append(row)
    
    # 打印三角形
    max_width = len(str(max(triangle[-1])))  # 最大数字宽度
    for i, row in enumerate(triangle):
        print(" " * (rows - i - 1) * (max_width + 1), end="")
        for num in row:
            print(f"{num:{max_width}d}", end=" ")
        print()

print_pascal_iter(8)

输出：

         1
       1 1
     1 2 1
   1 3 3 1
 1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1

for 循环点睛：

• 外层 for i 逐行构建。
• 内层 for j 根据上一行计算当前行中间值。
• 打印部分再次使用嵌套 for 控制对齐。

3. 案例二：数独求解器（回溯算法）

数独是 9×9 的网格，每行、每列和每个 3×3 宫（共 9 个）必须包含 1-9 各一次。我们将用 for 循环实现回溯法求解。

3.1 数独的表示

空白格用 0 表示，示例数独：

5 3 . | . 7 . | . . .
6 . . | 1 9 5 | . . .
. 9 8 | . . . | . 6 .
------+-------+------
8 . . | . 6 . | . . 3
4 . . | 8 . 3 | . . 1
7 . . | . 2 . | . . 6
------+-------+------
. 6 . | . . . | 2 8 .
. . . | 4 1 9 | . . 5
. . . | . 8 . | . 7 9

3.2 合法性检查函数

def is_valid(board, row, col, num):
    """检查在 (row, col) 处填入 num 是否合法"""
    # 检查行
    for j in range(9):
        if board[row][j] == num:
            return False
    # 检查列
    for i in range(9):
        if board[i][col] == num:
            return False
    # 检查所在 3x3 宫
    start_row, start_col = 3 * (row // 3), 3 * (col // 3)
    for i in range(start_row, start_row + 3):
        for j in range(start_col, start_col + 3):
            if board[i][j] == num:
                return False
    return True

for 循环点睛：

• 三个独立的 for 循环分别扫描行、列、宫。
• 宫内使用双重 for 遍历 3×3 区域。

3.3 回溯求解函数

def solve_sudoku(board):
    """使用回溯法求解数独（修改原 board），返回是否找到解"""
    for i in range(9):
        for j in range(9):
            if board[i][j] == 0:  # 找到空白格
                for num in range(1, 10):  # 尝试 1-9
                    if is_valid(board, i, j, num):
                        board[i][j] = num
                        if solve_sudoku(board):  # 递归求解剩余部分
                            return True
                        board[i][j] = 0  # 回溯
    return False  # 无解，回溯

return True  # 无空白格，求解完成

for 循环点睛：

• 双重 for 遍历整个棋盘，定位空白格。
• 内层 for num 枚举所有候选数字，依次尝试。
• 递归调用自身继续求解，利用 for 循环实现深度优先搜索。

3.4 打印函数

def print_sudoku(board):
    """美观打印数独棋盘"""
    for i in range(9):
        if i % 3 == 0 and i != 0:
            print("-" * 21)  # 每三行打印横线
        for j in range(9):
            if j % 3 == 0 and j != 0:
                print("|", end=" ")  # 每三列打印竖线
            print(board[i][j] if board[i][j] != 0 else ".", end=" ")
        print()

for 循环点睛：

• 外层 for i 控制行，内层 for j 控制列。
• 利用 % 运算符在适当位置添加分隔符，使棋盘清晰。

3.5 完整测试

# 定义数独（同上）
sudoku = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

print("原始数独：")
print_sudoku(sudoku)
if solve_sudoku(sudoku):
    print("\n解出的数独：")
    print_sudoku(sudoku)
else:
    print("无解")

输出（节选）：

原始数独：
5 3 . | . 7 . | . . .
6 . . | 1 9 5 | . . .
. 9 8 | . . . | . 6 .
------+-------+------
8 . . | . 6 . | . . 3
4 . . | 8 . 3 | . . 1
7 . . | . 2 . | . . 6
------+-------+------
. 6 . | . . . | 2 8 .
. . . | 4 1 9 | . . 5
. . . | . 8 . | . 7 9

解出的数独：
5 3 4 | 6 7 8 | 9 1 2
6 7 2 | 1 9 5 | 3 4 8
1 9 8 | 3 4 2 | 5 6 7
------+-------+------
8 5 9 | 7 6 1 | 4 2 3
4 2 6 | 8 5 3 | 7 9 1
7 1 3 | 9 2 4 | 8 5 6
------+-------+------
9 6 1 | 5 3 7 | 2 8 4
2 8 7 | 4 1 9 | 6 3 5
3 4 5 | 2 8 6 | 1 7 9

4. 总结

通过上述案例，我们可以看到 for 循环在 Python 编程中的核心地位：

• 遍历数据：无论是简单的列表、字典，还是复杂的二维网格，for 循环都能轻松遍历。
• 枚举尝试：在数独求解中，for num in range(1, 10) 枚举所有可能数字，是回溯算法的基石。
• 模式生成：杨辉三角的每一行都通过 for 循环递推构建，体现了循环与数学规律的结合。
• 格式化输出：利用 for 循环控制打印格式，可以输出美观的图形（如数独棋盘、杨辉三角）。

掌握 for 循环，是通往 Python 编程高手的重要一步。希望本文的讲解和案例能帮助你更深入地理解并灵活运用这一强大的工具。