跳到主要内容

Python 嵌套循环

什么是嵌套循环？​

嵌套循环是指在一个循环内部包含另一个循环的结构。在Python中，我们可以将for循环或while循环放置在另一个循环内部，形成多层次的循环结构。这种结构特别适合处理多维数据或需要多重迭代的情况。

嵌套循环的基本工作原理是：外层循环每执行一次，内层循环将完整执行一遍。这意味着如果外层循环执行n次，内层循环执行m次，那么内层循环体的代码将执行n×m次。

嵌套循环的基本语法​

嵌套for循环​

python
for 外层变量 in 外层序列:
    # 外层循环体代码
    for 内层变量 in 内层序列:
        # 内层循环体代码
        # 这里的代码会执行（外层序列长度 × 内层序列长度）次

嵌套while循环​

python
while 外层条件:
    # 外层循环体代码
    while 内层条件:
        # 内层循环体代码
        # 记得更新内层条件，避免无限循环
    # 记得更新外层条件，避免无限循环

嵌套循环的工作流程​

让我们通过一个简单的例子来理解嵌套循环的工作流程：

python
# 简单的嵌套for循环示例
for i in range(3):  # 外层循环
    print(f"外层循环: i = {i}")
    for j in range(2):  # 内层循环
        print(f"  内层循环: j = {j}")

输出结果：

外层循环: i = 0
  内层循环: j = 0
  内层循环: j = 1
外层循环: i = 1
  内层循环: j = 0
  内层循环: j = 1
外层循环: i = 2
  内层循环: j = 0
  内层循环: j = 1

从输出可以看出：

  1. 外层循环执行了3次（i分别为0、1、2）
  2. 每当外层循环执行一次时，内层循环都完整执行了2次（j分别为0、1）
  3. 总共执行了3×2=6次内层循环体代码
执行顺序

嵌套循环的执行遵循"由外到内"的原则。外层循环先执行一步，然后内层循环完整执行一遍，接着外层循环执行下一步，内层循环再次完整执行一遍，如此往复。

常见的嵌套循环应用场景​

1. 处理二维数据结构​

嵌套循环特别适合处理二维列表（矩阵）等多维数据结构：

python
# 创建一个3x3的矩阵
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 使用嵌套循环遍历矩阵中的每个元素
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"matrix[{i}][{j}] = {matrix[i][j]}", end="  ")
    print()  # 每行结束后换行

输出结果：

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

2. 生成组合数据​

嵌套循环可以用来生成所有可能的组合：

python
# 生成两个列表中所有元素的组合
fruits = ['apple', 'banana', 'orange']
colors = ['red', 'green', 'yellow']

combinations = []
for fruit in fruits:
    for color in colors:
        combinations.append(f"{color} {fruit}")

print(combinations)

输出结果：

['red apple', 'green apple', 'yellow apple', 'red banana', 'green banana', 'yellow banana', 'red orange', 'green orange', 'yellow orange']

3. 打印图案​

嵌套循环非常适合打印各种图案：

python
# 打印一个三角形图案
rows = 5
for i in range(rows):
    for j in range(i + 1):
        print("*", end=" ")
    print()  # 换行

输出结果：

* 
* * 
* * * 
* * * * 
* * * * *

嵌套循环的效率考虑​

嵌套循环的时间复杂度通常是各层循环复杂度的乘积。例如，两层for循环的时间复杂度通常是O(n²)，三层嵌套循环的时间复杂度通常是O(n³)。

因此，当处理大数据集时，需要注意嵌套循环可能导致的性能问题。以下是一些优化建议：

  1. 尽量减少不必要的嵌套层数：每增加一层嵌套，计算复杂度就会大幅增加。
  2. 在嵌套循环中尽早使用break或continue：适当地跳过不必要的计算可以提高效率。
  3. 考虑使用列表推导式或生成器表达式：有时它们能提供更简洁、更高效的替代方案。

嵌套循环中断与跳过​

在嵌套循环中使用break和continue语句时，需要注意它们只会影响它们所在的当前循环层级：

python
for i in range(3):
    print(f"外层循环 i={i}")
    for j in range(3):
        if j == 1:
            print(f"  跳过 j={j}")
            continue  # 只跳过当前内层循环的迭代
        if i == 1 and j == 2:
            print(f"  中断内层循环，i={i}, j={j}")
            break  # 只中断内层循环
        print(f"  内层循环 j={j}")

输出结果：

外层循环 i=0
  内层循环 j=0
  跳过 j=1
  内层循环 j=2
外层循环 i=1
  内层循环 j=0
  跳过 j=1
  中断内层循环，i=1, j=2
外层循环 i=2
  内层循环 j=0
  跳过 j=1
  内层循环 j=2

如果要从嵌套循环中完全跳出，可以使用标志变量或函数返回值等方法。

实际应用案例​

案例1：查找重复元素​

假设我们需要找出一个列表中所有重复出现的元素：

python
def find_duplicates(nums):
    duplicates = []
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] == nums[j] and nums[i] not in duplicates:
                duplicates.append(nums[i])
                break  # 找到一个重复就跳出内层循环
    return duplicates

numbers = [1, 2, 3, 2, 4, 5, 3, 6, 4]
duplicated = find_duplicates(numbers)
print(f"重复的元素有: {duplicated}")

输出结果：

重复的元素有: [2, 3, 4]

案例2：简单的表格数据处理​

假设我们有学生的成绩数据，需要计算每个学生的平均分和班级每门课的平均分：

python
# 学生成绩数据 [数学, 语文, 英语]
student_scores = [
    [85, 90, 78],  # 学生1
    [92, 88, 95],  # 学生2
    [78, 82, 80],  # 学生3
    [90, 85, 88]   # 学生4
]

# 计算每个学生的平均分
print("每个学生的平均分:")
for i, scores in enumerate(student_scores):
    total = 0
    for score in scores:
        total += score
    average = total / len(scores)
    print(f"学生{i+1}的平均分: {average:.2f}")

# 计算每门课的平均分
print("\n每门课的平均分:")
subject_names = ["数学", "语文", "英语"]
for j in range(len(student_scores[0])):
    total = 0
    for i in range(len(student_scores)):
        total += student_scores[i][j]
    average = total / len(student_scores)
    print(f"{subject_names[j]}的平均分: {average:.2f}")

输出结果：

每个学生的平均分:
学生1的平均分: 84.33
学生2的平均分: 91.67
学生3的平均分: 80.00
学生4的平均分: 87.67

每门课的平均分:
数学的平均分: 86.25
语文的平均分: 86.25
英语的平均分: 85.25

案例3：日历打印​

使用嵌套循环打印简单的月历：

python
def print_calendar(year, month, days_in_month, start_day):
    print(f"\n{year}年{month}月")
    print("一  二  三  四  五  六  日")
    
    # 打印第一行的空白部分
    for i in range(start_day):
        print("   ", end="")
    
    # 打印日期
    day_count = start_day
    for day in range(1, days_in_month + 1):
        print(f"{day:2d} ", end="")
        day_count += 1
        
        # 每到周日换行
        if day_count % 7 == 0:
            print()
    
    print()  # 结束时换行

print_calendar(2023, 10, 31, 6)  # 2023年10月，31天，从周日开始(索引为6)

输出结果：

2023年10月
一  二  三  四  五  六  日
                      1 
 2  3  4  5  6  7  8 
 9 10 11 12 13 14 15 
16 17 18 19 20 21 22 
23 24 25 26 27 28 29 
30 31

嵌套循环与列表推导式​

对于某些简单的嵌套循环，我们可以使用列表推导式来简化代码：

python
# 使用嵌套循环生成二维列表
matrix = []
for i in range(3):
    row = []
    for j in range(3):
        row.append(i * 3 + j + 1)
    matrix.append(row)

print("使用嵌套循环生成的矩阵:")
for row in matrix:
    print(row)

# 使用列表推导式生成相同的二维列表
matrix_comp = [[i * 3 + j + 1 for j in range(3)] for i in range(3)]

print("\n使用列表推导式生成的矩阵:")
for row in matrix_comp:
    print(row)

输出结果：

使用嵌套循环生成的矩阵:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

使用列表推导式生成的矩阵:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
注意

虽然列表推导式通常更简洁，但对于复杂的嵌套循环逻辑，使用标准的循环结构可能更清晰易懂。代码的可读性有时比简洁性更重要。

总结​

嵌套循环是Python编程中处理多维数据和复杂迭代的强大工具：

  1. 基本概念：在一个循环内部包含另一个循环，形成多层次的迭代结构。
  2. 执行顺序：外层循环每执行一次，内层循环将完整执行一遍。
  3. 适用场景：
    • 处理二维数据结构（如矩阵、表格）
    • 生成所有可能的组合
    • 打印复杂图案
    • 多维数据分析
  4. 效率考虑：嵌套循环的时间复杂度是各层循环复杂度的乘积，处理大数据时需小心。
  5. 流程控制：break和continue语句只影响它们所在的当前循环层级。
  6. 简化方法：对于简单的嵌套循环，可以考虑使用列表推导式。

掌握嵌套循环是编写高效Python代码的重要一步，它能帮助你解决许多实际编程问题，特别是在数据处理和分析领域。

练习​

为了巩固您对嵌套循环的理解，请尝试以下练习：

  1. 编写一个程序，使用嵌套循环打印一个10×10的乘法表。
  2. 使用嵌套循环实现冒泡排序算法。
  3. 创建一个程序，找出两个列表中所有可能的数对，使它们的和等于一个特定值。
  4. 编写一个函数，使用嵌套循环检测一个词是否为回文词（正读反读都一样）。
  5. 使用嵌套循环创建一个程序，打印杨辉三角形的前10行。

通过这些练习，你将能够更好地理解和应用Python中的嵌套循环结构。

学习建议

学习嵌套循环时，建议从简单的例子开始，逐步分析代码的执行流程。可以使用纸笔手动追踪变量的变化，或者使用调试工具逐行执行代码，这有助于深入理解循环的嵌套机制。