Python - 嵌套循环

你好，有抱负的程序员们！今天，我们将深入探讨 Python 中的嵌套循环这一迷人的世界。作为你友好的邻居电脑老师，我非常激动地引导你完成这次学习之旅。相信我，在本节课结束时，你将能够像专业人士一样进行循环操作！

什么是嵌套循环？

在我们深入探讨之前，先从基础开始。想象一下你在整理衣柜。你逐个检查每个架子（这是一个循环），并且对于每个架子，你都会整理上面的所有物品（这是另一个循环，嵌套在第一个循环里面）。在编程中，嵌套循环本质上就是这样——循环中嵌套着循环！

Python 嵌套 for 循环

让我们从 for 循环开始，它在 Python 世界中就像一个可靠的老朋友。

基本结构

以下是嵌套 for 循环的一般结构：

for outer_variable in outer_sequence:
# 外层循环体
for inner_variable in inner_sequence:
# 内层循环体

简单示例：乘法表

让我们创建一个简单的乘法表来更好地理解这一点：

for i in range(1, 6):
for j in range(1, 6):
print(f"{i} x {j} = {i*j}", end="\t")
print()  # 在每一行后移动到下一行

这段代码将输出：

1 x 1 = 1    1 x 2 = 2    1 x 3 = 3    1 x 4 = 4    1 x 5 = 5
2 x 1 = 2    2 x 2 = 4    2 x 3 = 6    2 x 4 = 8    2 x 5 = 10
3 x 1 = 3    3 x 2 = 6    3 x 3 = 9    3 x 4 = 12   3 x 5 = 15
4 x 1 = 4    4 x 2 = 8    4 x 3 = 12   4 x 4 = 16   4 x 5 = 20
5 x 1 = 5    5 x 2 = 10   5 x 3 = 15   5 x 4 = 20   5 x 5 = 25

让我们分解一下：

1. 外层循环（for i in range(1, 6)）运行 5 次，代表行。
2. 对于外层循环的每次迭代，内层循环（for j in range(1, 6)）运行 5 次，代表列。
3. 我们打印每个乘法结果，使用 end="\t" 添加一个制表符而不是新行。
4. 在每一行（外层循环迭代）之后，我们打印一个空行以移动到下一行。

实际示例：座位安排

想象一下你是一个老师（像我一样！），正在为一个班级安排座位。让我们创建一个座位表：

students = ["Alice", "Bob", "Charlie", "David", "Eve"]
rows = 3
seats_per_row = 2

seat_number = 0
for row in range(1, rows + 1):
print(f"Row {row}:")
for seat in range(1, seats_per_row + 1):
if seat_number < len(students):
print(f"  Seat {seat}: {students[seat_number]}")
seat_number += 1
else:
print(f"  Seat {seat}: Empty")
print()  # 行与行之间的空行

这将输出：

Row 1:
Seat 1: Alice
Seat 2: Bob

Row 2:
Seat 1: Charlie
Seat 2: David

Row 3:
Seat 1: Eve
Seat 2: Empty

在这个例子中：

1. 外层循环遍历每一行。
2. 内层循环为每行的座位分配学生。
3. 我们使用一个 seat_number 变量来跟踪下一个要分配的学生。
4. 如果学生用完了，我们将剩余的座位标记为“Empty”。

Python 嵌套 while 循环

现在，让我们来了解一下 while 循环的表亲——嵌套 while 循环。它就像一个警惕的守卫，不断检查一个条件。

基本结构

以下是嵌套 while 循环通常的外观：

while outer_condition:
# 外层循环体
while inner_condition:
# 内层循环体

示例：数字金字塔

让我们创建一个数字金字塔来看看嵌套 while 循环的作用：

row = 1
while row <= 5:
col = 1
while col <= row:
print(col, end=" ")
col += 1
print()  # 移动到下一行
row += 1

这将输出：

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

让我们分解一下：

1. 外层 while 循环控制行数（1 到 5）。
2. 对于每一行，内层 while 循环打印从 1 到当前行数的数字。
3. 我们在内层循环中递增 col，在外层循环中递增 row。

实际示例：库存检查

想象一下你正在管理一个小商店。你需要定期检查库存。让我们用嵌套 while 循环来模拟这个过程：

inventory = {
"apples": 50,
"bananas": 30,
"oranges": 40
}

days = 1
while days <= 3:  # 检查 3 天
print(f"Day {days} Inventory Check:")
for fruit, quantity in inventory.items():
while quantity > 0:
print(f"Checking {fruit}...")
quantity -= 10  # 每次检查模拟销售 10 个单位
if quantity <= 20:
print(f"Low stock alert for {fruit}! Only {quantity} left.")
break  # 如果库存低，停止检查这种水果
inventory[fruit] = quantity  # 更新库存
print(f"End of Day {days} Inventory: {inventory}\n")
days += 1

这将输出类似以下内容：

Day 1 Inventory Check:
Checking apples...
Checking apples...
Checking apples...
Low stock alert for apples! Only 20 left.
Checking bananas...
Low stock alert for bananas! Only 20 left.
Checking oranges...
Checking oranges...
Low stock alert for oranges! Only 20 left.
End of Day 1 Inventory: {'apples': 20, 'bananas': 20, 'oranges': 20}

Day 2 Inventory Check:
Checking apples...
Low stock alert for apples! Only 10 left.
Checking bananas...
Low stock alert for bananas! Only 10 left.
Checking oranges...
Low stock alert for oranges! Only 10 left.
End of Day 2 Inventory: {'apples': 10, 'bananas': 10, 'oranges': 10}

Day 3 Inventory Check:
Checking apples...
Low stock alert for apples! Only 0 left.
Checking bananas...
Low stock alert for bananas! Only 0 left.
Checking oranges...
Low stock alert for oranges! Only 0 left.
End of Day 3 Inventory: {'apples': 0, 'bananas': 0, 'oranges': 0}

在这个例子中：

1. 外层 while 循环模拟检查 3 天的库存。
2. 我们使用一个 for 循环遍历库存中的每种水果。
3. 内层 while 循环模拟检查并销售每种水果，直到库存低或售罄。
4. 如果数量降到 20 以下，我们使用 break 停止检查这种水果。

结论

恭喜你！你已经掌握了 Python 中嵌套循环的艺术。请记住，嵌套循环是强大的工具，但请明智地使用。如果使用不当，它们可能会使你的代码运行变慢。

就像所有编程概念一样，实践是完美的。尝试创建自己的嵌套循环场景——也许是一个棋盘设置，或者是一周的学校课程表。可能性是无限的！

继续编码，继续学习，最重要的是，玩得开心！下次见，这是你友好的邻居电脑老师签名。快乐的循环！

Credits: Image by storyset