23.Python循环进阶教程：嵌套与控制

全栈若城

发布于 2025-04-25 10:22:08

6530

文章被收录于专栏：若城技术专栏若城技术专栏

一、Python循环嵌套 🎯

1. 什么是循环嵌套？

循环嵌套是指在一个循环内部再放置另一个循环的编程结构。简单来说，就是"循环中的循环"。

# 循环嵌套的基本结构
# 外层循环
for 外层变量 in 外层序列:
    # 内层循环
    for 内层变量 in 内层序列:
        # 执行的代码
        print(外层变量, 内层变量)

2. 循环嵌套的工作原理

当程序执行到嵌套循环时：

首先执行外层循环一次
然后执行内层循环的所有次数
再回到外层循环执行第二次
再次执行内层循环的所有次数
以此类推，直到外层循环结束

3. 实际例子

例子1：打印乘法表

# 打印九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j} × {i} = {i*j}", end="\t")
    print()  # 换行

这段代码会打印出九九乘法表，外层循环控制行数，内层循环控制每行的列数。

例子2：遍历二维列表

# 二维列表
班级 = [
    ["小明", "小红", "小刚"],
    ["大壮", "大力", "大山"],
    ["阿花", "阿朵", "阿蓝"]
]

# 遍历二维列表
for 班 in 班级:
    for 学生 in 班:
        print(f"学生姓名: {学生}")
    print("---这个班的学生已点名完毕---")

4. 嵌套循环的注意事项

性能考虑：嵌套循环会导致代码执行次数成倍增加，时间复杂度为O(n²)
缩进清晰：保持代码缩进清晰，便于阅读和维护
避免过深嵌套：一般不建议超过3层嵌套，否则代码可读性会大大降低

二、Python嵌套循环实现冒泡排序 🔍

1. 什么是冒泡排序？

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，一次比较两个元素，如果顺序错误就交换它们。

2. 冒泡排序的原理

比较相邻的元素。如果第一个比第二个大，就交换它们
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对
这步做完后，最后的元素会是最大的数
针对所有的元素重复以上的步骤，除了最后一个
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

3. 使用嵌套循环实现冒泡排序

def 冒泡排序(列表):
    长度 = len(列表)
    
    # 外层循环控制排序轮数
    for i in range(长度):
        # 内层循环进行相邻元素比较
        for j in range(0, 长度-i-1):
            # 如果当前元素大于下一个元素，则交换
            if 列表[j] > 列表[j+1]:
                列表[j], 列表[j+1] = 列表[j+1], 列表[j]
    
    return 列表

# 测试冒泡排序
数字列表 = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", 数字列表)
排序后列表 = 冒泡排序(数字列表)
print("排序后:", 排序后列表)

4. 冒泡排序的可视化解释

假设我们有列表 [5, 3, 8, 4, 2]：

第一轮外层循环：

比较 5 和 3，交换 → [3, 5, 8, 4, 2]
比较 5 和 8，不交换 → [3, 5, 8, 4, 2]
比较 8 和 4，交换 → [3, 5, 4, 8, 2]
比较 8 和 2，交换 → [3, 5, 4, 2, 8]

第二轮外层循环：

比较 3 和 5，不交换 → [3, 5, 4, 2, 8]
比较 5 和 4，交换 → [3, 4, 5, 2, 8]
比较 5 和 2，交换 → [3, 4, 2, 5, 8]

以此类推，直到列表完全排序。

5. 冒泡排序的优化

def 优化冒泡排序(列表):
    长度 = len(列表)
    
    # 外层循环控制排序轮数
    for i in range(长度):
        已排序 = True  # 假设列表已经排序好了
        
        # 内层循环进行相邻元素比较
        for j in range(0, 长度-i-1):
            # 如果当前元素大于下一个元素，则交换
            if 列表[j] > 列表[j+1]:
                列表[j], 列表[j+1] = 列表[j+1], 列表[j]
                已排序 = False  # 如果有交换，说明列表还没完全排序
        
        # 如果没有发生交换，说明列表已经排序完成
        if 已排序:
            break
    
    return 列表

三、Python break：跳出当前循环体 ⏹️

1. break语句的作用

break语句用于跳出当前所在的整个循环体，不再执行循环中剩余的语句。

2. break的基本用法

for 变量 in 序列:
    # 循环体代码
    if 条件:
        break  # 满足条件时，跳出整个循环
    # break后的循环体代码不会执行

3. break在单层循环中的应用

例子1：查找列表中的特定元素

水果列表 = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]
目标 = "橙子"

for 水果 in 水果列表:
    print(f"正在检查: {水果}")
    if 水果 == 目标:
        print(f"找到了{目标}！")
        break  # 找到目标后立即结束循环

print("搜索结束")

例子2：用户输入控制

while True:
    用户输入 = input("请输入一个数字(输入'q'退出): ")
    
    if 用户输入 == 'q':
        print("程序结束")
        break
    
    try:
        数字 = int(用户输入)
        print(f"您输入的数字是: {数字}")
    except ValueError:
        print("输入无效，请输入数字或'q'退出")

4. break在嵌套循环中的应用

在嵌套循环中，break只会跳出当前所在的循环，而不会跳出外层循环。

for i in range(3):
    print(f"外层循环: {i}")
    for j in range(3):
        print(f"  内层循环: {j}")
        if j == 1:
            print("  遇到j=1，跳出内层循环")
            break  # 只跳出内层循环，外层循环继续执行

5. 如何跳出嵌套循环的所有层级？

如果需要一次性跳出所有循环层级，可以使用以下方法：

方法1：使用标志变量

已找到 = False

for i in range(5):
    for j in range(5):
        if i * j > 10:
            print(f"找到满足条件的值: {i} * {j} = {i*j}")
            已找到 = True
            break  # 跳出内层循环
    
    if 已找到:
        break  # 跳出外层循环

方法2：使用函数返回

def 查找():
    for i in range(5):
        for j in range(5):
            if i * j > 10:
                print(f"找到满足条件的值: {i} * {j} = {i*j}")
                return  # 直接返回，跳出所有循环

查找()

6. break与continue的区别

break：完全跳出当前循环，不再执行循环中的任何代码
continue：跳过当前循环的剩余部分，直接进入下一次循环

# break示例
for i in range(5):
    if i == 2:
        break  # i=2时跳出循环
    print(i)  # 只会打印0,1

# continue示例
for i in range(5):
    if i == 2:
        continue  # i=2时跳过当前循环
    print(i)  # 会打印0,1,3,4