课时 8：循环语句（for 循环）

---

---

四、循环嵌套

4.1 循环嵌套的基本概念

循环嵌套是指在一个循环体内包含另一个完整的循环结构。外层循环执行一次，内层循环会执行多次，直到内层循环完成所有迭代。

基本语法结构：

for 变量1 in 可迭代对象1:
    # 外层循环体
    for 变量2 in 可迭代对象2:
        # 内层循环体

执行逻辑：

1. 外层循环变量 1 取第一个值。

2. 内层循环变量 2 遍历可迭代对象 2 的所有值，执行内层循环体。

3. 外层循环变量 1 取下一个值。

4. 重复步骤 2 和 3，直到外层循环变量 1 遍历完所有值。

执行次数：

内层循环体的总执行次数 = 外层循环次数 × 内层循环次数。

4.2 双层 for 循环应用示例

示例 1：打印九九乘法表

九九乘法表是循环嵌套的经典案例，通过双层 for 循环可以轻松实现。

实现思路：

• 外层循环控制行数，从 1 到 9。

• 内层循环控制每行的列数，从 1 到当前行数。

• 内层循环中打印当前行和列的乘积。

代码实现：

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j}\t", end='')
    print()  # 换行

执行结果：

1×1=1        

1×2=2        2×2=4        

1×3=3        2×3=6        3×3=9        

1×4=4        2×4=8        3×4=12        4×4=16        

...

1×9=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

代码解析：

• 外层循环for i in range(1, 10)控制行数，i 从 1 到 9。

• 内层循环for j in range(1, i + 1)控制每行的列数，j 从 1 到 i。

• print(f"{j}×{i}={i*j}\t", end='')打印当前乘积，并使用制表符\t对齐。

• print()用于换行，确保每行结束后换行。

示例 2：打印直角三角形

另一个经典的循环嵌套案例是打印直角三角形，这里我们将学习如何用星号*打印直角三角形。

实现思路：

• 外层循环控制行数，从 1 到 n（n 为三角形高度）。

• 内层循环控制每行的星号数量，从 1 到当前行数。

• 内层循环中打印星号。

代码实现：

# 定义三角形高度
height = 5

# 外层循环控制行数
for i in range(1, height + 1):
    # 内层循环控制每行的星号数量
    for j in range(1, i + 1):
        print("*", end=' ')
    print()  # 换行

执行结果：

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

变形 1：打印右对齐的直角三角形

height = 5
for i in range(1, height + 1):
    # 打印前面的空格
    for k in range(height - i):
        print(" ", end='')
    # 打印星号
    for j in range(1, i + 1):
        print("*", end='')
    print()

执行结果：

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

变形 2：打印倒直角三角形

height = 5
for i in range(height, 0, -1):
    for j in range(1, i + 1):
        print("*", end=' ')
    print()

执行结果：

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

4.3 循环嵌套的执行流程

为了更好地理解循环嵌套的执行流程，我们可以通过以下步骤来分析：

1. 外层循环开始：外层循环变量取第一个值。

2. 内层循环开始：内层循环变量取第一个值。

3. 执行内层循环体：执行缩进的内层循环代码。

4. 内层循环变量取下一个值：重复步骤 3，直到内层循环结束。

5. 外层循环变量取下一个值：重复步骤 2-4，直到外层循环结束。

示例：双层循环执行流程

for i in range(1, 3):
    print(f"外层循环i={i}")
    for j in range(1, 3):
        print(f"  内层循环j={j}")

执行流程：

1. 外层循环 i=1：

• 内层循环 j=1 → 打印 “内层循环 j=1”

• 内层循环 j=2 → 打印 “内层循环 j=2”

1. 外层循环 i=2：

• 内层循环 j=1 → 打印 “内层循环 j=1”

• 内层循环 j=2 → 打印 “内层循环 j=2”

执行结果：

for i in range(1, 3):
    print(f"i={i}")
    for j in range(1, 3):
        print(f"  j={j}")
        for k in range(1, 3):
            print(f"    k={k}")

4.4 多层循环嵌套

除了双层循环，Python 还支持多层循环嵌套，即在内层循环中再包含其他循环结构。

示例：三层循环

for i in range(1, 3):
    print(f"i={i}")
    for j in range(1, 3):
        print(f"  j={j}")
        for k in range(1, 3):
            print(f"    k={k}")

执行结果：

i=1
  j=1
    k=1
    k=2
  j=2
    k=1
    k=2
i=2
  j=1
    k=1
    k=2
  j=2
    k=1
    k=2

注意事项：

• 随着循环嵌套层数的增加，代码的复杂度和执行时间会急剧增加。

• 多层循环嵌套应谨慎使用，确保逻辑清晰，避免不必要的嵌套。

• 通常情况下，三层以上的循环嵌套会导致代码可读性和性能下降。

五、for 循环的常见错误（10 分钟）

5.1 循环变量作用域问题

在使用 for 循环时，循环变量的作用域是一个容易出错的地方：

错误 1：在循环外部访问循环变量

# 错误示例：在循环外部访问循环变量
for i in range(5):
    print(i)
print(f"循环外i的值：{i}")  # 虽然可以执行，但不规范

错误原因：虽然在 Python 中可以在循环外部访问循环变量，但这不符合编程规范，可能导致代码可读性降低和意外错误。

正确做法：如果需要在循环外部使用循环变量的值，应在循环外部提前定义该变量：

# 正确示例：在循环外部定义变量
i = 0
for i in range(5):
    print(i)
print(f"循环外i的值：{i}")  # 现在没有警告了

错误 2：在嵌套循环中使用相同的循环变量名

# 错误示例：在嵌套循环中使用相同的变量名
for i in range(5):
    for i in range(3):
        print(i)

错误原因：内层循环的变量 i 会覆盖外层循环的变量 i，导致外层循环变量的值被改变。

正确做法：为不同层次的循环使用不同的变量名：

# 正确示例：使用不同的变量名
for i in range(5):
    for j in range(3):
        print(j)

5.2 range () 函数参数错误

range () 函数的参数使用也是一个常见的错误点：

错误 1：range () 函数参数顺序错误

# 错误示例：start和stop参数顺序颠倒
for i in range(5, 0):
    print(i)  # 不会输出任何内容

错误原因：当 start 大于 stop 且步长为正数时，range () 函数生成的序列为空。

正确做法：确保参数顺序正确，并根据需要设置步长：

# 正确示例：使用正确的参数顺序和步长
for i in range(5, 0, -1):
    print(i)  # 输出5,4,3,2,1

错误 2：忘记设置步长导致结果不符合预期

# 错误示例：生成偶数序列时忘记设置步长
for i in range(0, 10):
    print(i)  # 输出0到9，不是偶数

错误原因：默认步长为 1，生成的是连续整数序列。

正确做法：设置合适的步长参数：

# 正确示例：设置步长为2生成偶数序列
for i in range(0, 10, 2):
    print(i)  # 输出0,2,4,6,8

错误 3：range () 函数参数类型错误

# 错误示例：使用浮点数作为range()函数参数
for i in range(0.5, 5.5, 0.5):
    print(i)  # 会抛出TypeError

错误原因：range () 函数的参数必须是整数。

正确做法：确保所有参数都是整数：

# 正确示例：使用整数参数
for i in range(1, 11):
    print(i)

5.3 循环嵌套中的缩进错误

缩进错误是 Python 编程中最常见的错误之一，在循环嵌套中尤为明显：

错误 1：内层循环体忘记缩进

# 错误示例：内层循环体忘记缩进
for i in range(5):
for j in range(3):  # 错误：缺少缩进
    print(j)

错误原因：Python 根据缩进判断代码块的归属，内层循环体必须缩进。

正确做法：确保内层循环体有正确的缩进：

# 正确示例：内层循环体正确缩进
for i in range(5):
    for j in range(3):
        print(j)

错误 2：循环体代码缩进不一致

# 错误示例：缩进不一致
for i in range(5):
    print("外层循环")  # 缩进4个空格
  print("内层循环")  # 缩进2个空格，错误

错误原因：同一层次的代码必须使用相同的缩进量。

正确做法：使用一致的缩进风格（通常为 4 个空格）：

# 正确示例：一致的缩进
for i in range(5):
    print("外层循环")
    for j in range(3):
        print("内层循环")

错误 3：在循环外部意外缩进

# 错误示例：在循环外部意外缩进
for i in range(5):
    print(i)
print("循环结束")  # 正确，没有缩进
    print("错误缩进")  # 错误：意外缩进

错误原因：意外的缩进会导致代码被错误地包含在循环体中。

正确做法：确保非循环体代码没有不必要的缩进：

# 正确示例：正确的缩进
for i in range(5):
    print(i)
print("循环结束")

5.4 其他常见错误

错误 1：在循环体内修改循环变量的值

# 错误示例：在循环体内修改循环变量的值
for i in range(5):
    print(i)
    i = 10  # 这不会改变循环的执行顺序

错误原因：在循环体内修改循环变量的值不会影响循环的执行顺序，因为每次循环都会重新赋值循环变量。

正确做法：不要在循环体内修改循环变量的值，这不会产生预期的效果。

错误 2：在循环体内使用 break 语句后忘记处理剩余逻辑

# 错误示例：break后未处理剩余逻辑
numbers = [1, 2, 3, 4, 5]
found = False
for num in numbers:
    if num == 3:
        found = True
        break
# 这里需要处理found为True的情况，但代码中没有

错误原因：break 语句会立即退出循环，如果需要在找到目标后执行某些操作，应在循环外部处理。

正确做法：在循环外部处理 break 后的逻辑：

# 正确示例：在循环外部处理break后的逻辑
numbers = [1, 2, 3, 4, 5]
found = False
for num in numbers:
    if num == 3:
        found = True
        break
if found:
    print("找到了数字3")
else:
    print("没有找到数字3")

六、综合练习与课堂实践

现在，我们将通过几个实践练习来巩固今天所学的知识。请打开 PyCharm，创建一个新的 Python 文件，命名为for_loop_practice.py，然后按照以下练习进行操作。

6.1 基础练习：遍历与输出

练习 1：遍历列表并输出元素及其索引

编写一个程序，定义一个包含 5 个元素的列表，然后使用 for 循环和 range () 函数遍历列表，输出每个元素及其索引。

示例输出：

索引0：元素1

索引1：元素2

索引2：元素3

索引3：元素4

索引4：元素5

提示：可以结合 range () 函数和 len () 函数生成索引序列。

练习 2：生成并输出特定序列

编写一个程序，使用 for 循环和 range () 函数生成并输出以下序列：

1. 0 到 9 的整数序列

2. 2 到 10 的偶数序列

3. 10 到 1 的倒序序列

4. 1 到 15 的奇数序列

示例输出：

0 1 2 3 4 5 6 7 8 9 
2 4 6 8 10 
10 9 8 7 6 5 4 3 2 1 
1 3 5 7 9 11 13 15 

提示：可以使用 print () 函数的 end 参数来控制输出格式。

6.2 进阶练习：循环嵌套应用

练习 3：打印直角三角形

编写一个程序，要求用户输入一个整数 n，然后使用 for 循环嵌套打印一个高度为 n 的直角三角形，使用星号*表示。

示例输入输出：

请输入三角形高度：5
* 
* * 
* * * 
* * * * 
* * * * * 

提示：外层循环控制行数，内层循环控制每行的星号数量。

练习 4：打印九九乘法表

编写一个程序，使用 for 循环嵌套打印九九乘法表，要求格式整齐美观。

示例输出：

1×1=1        
1×2=2        2×2=4        
1×3=3        2×3=6        3×3=9        
1×4=4        2×4=8        3×4=12        4×4=16        
...
1×9=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

提示：外层循环控制行数，内层循环控制每行的列数，可以使用制表符\t来对齐输出。

6.3 挑战练习：模式打印

练习 5：打印菱形

编写一个程序，要求用户输入一个奇数 n，然后使用 for 循环嵌套打印一个高度为 n 的菱形，使用星号*表示。

示例输入输出：

请输入菱形高度（奇数）：5
  * 
 *** 
***** 
 *** 
  * 

提示：可以将菱形分为上半部分和下半部分，分别使用循环嵌套打印。

练习 6：打印字母三角形

编写一个程序，打印一个由字母组成的三角形，如下所示：

A

B B

C C C

D D D D

E E E E E

提示：可以使用 chr () 函数将 ASCII 码转换为对应的字母。

七、课程总结（5 分钟）

今天的课程中，我们学习了 Python 中的 for 循环和 range () 函数，以及它们的应用场景和注意事项。这些内容是 Python 编程中非常基础且重要的部分，是编写高效、简洁代码的关键。

重点回顾：

1. for 循环基础：

• for 循环用于遍历可迭代对象，如列表、字符串、元组等。

• 基本语法：for 变量 in 可迭代对象: 循环体。

• 循环体必须缩进，通常为 4 个空格。

1. range () 函数：

• 用于生成数字序列，语法：range(start, stop, step)。

• 三种形式：range(stop)、range(start, stop)、range(start, stop, step)。

• range 对象是可迭代对象，不是列表，内存使用更高效。

1. 循环嵌套：

• 在一个循环体内包含另一个完整的循环结构。

• 外层循环执行一次，内层循环执行多次。

• 经典应用：九九乘法表、直角三角形等。

1. 常见错误：

• 循环变量作用域问题：避免在循环外部访问循环变量。

• range () 函数参数错误：注意参数顺序和类型。

• 缩进错误：确保代码块缩进正确。

课后任务：

1. 复习今天所学的内容，确保完全理解 for 循环和 range () 函数的使用。

2. 完成课堂练习中的六个实践任务。

3. 预习下一节课的内容：循环语句（while 循环）。

下一节课中，我们将学习另一种循环结构 ——while 循环，以及如何结合条件语句和循环语句编写更复杂的程序。

如果你在学习过程中遇到任何问题，请随时提问。祝你学习愉快！

八、常见问题与解答

8.1 for 循环相关问题

问题 1：for 循环中的变量在循环结束后是否还能访问？

解答：虽然在实际编程中可以在循环外部访问循环变量，但这是不规范的做法，可能导致代码可读性降低和意外错误。在编程规范上，不允许也不建议在循环外部访问循环变量。

问题 2：如何在 for 循环中同时获取元素的索引和值？

解答：可以使用 range () 函数和 len () 函数结合，或者使用 enumerate () 函数：

# 使用range()和len()
fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"索引{i}：{fruits[i]}")

# 使用enumerate()
for index, fruit in enumerate(fruits):
    print(f"索引{index}：{fruit}")

问题 3：如何在 for 循环中跳过某些元素？

解答：可以使用 continue 语句跳过特定元素：

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        continue
    print(num)

8.2 range () 函数相关问题

问题 1：range () 函数生成的序列是否包含 stop 参数的值？

解答：不包含。range () 函数生成的序列是左闭右开的，即包括 start 参数的值，但不包括 stop 参数的值。

问题 2：如何生成从 5 到 1 的倒序序列？

解答：可以使用负数步长：

for i in range(5, 0, -1):
    print(i)

问题 3：range () 函数和列表有什么区别？

解答：range () 函数返回的是一个 range 对象，而不是列表。列表会立即创建并存储所有元素，占用较多内存；而 range 对象是一个轻量级的可迭代对象，按需生成元素，内存使用更高效。

8.3 循环嵌套相关问题

问题 1：如何理解循环嵌套的执行顺序？

解答：外层循环执行一次，内层循环执行多次。外层循环变量取第一个值，内层循环变量遍历所有值；然后外层循环变量取下一个值，内层循环再次遍历所有值，依此类推。

问题 2：如何打印一个右对齐的直角三角形？

解答：可以在打印星号前先打印一定数量的空格：

height = 5
for i in range(1, height + 1):
    # 打印前面的空格
    for k in range(height - i):
        print(" ", end='')
    # 打印星号
    for j in range(1, i + 1):
        print("*", end='')
    print()

问题 3：如何打印一个由数字组成的三角形？

解答：可以在内层循环中打印当前行号：

height = 5
for i in range(1, height + 1):
    for j in range(1, i + 1):
        print(i, end=' ')
    print()

九、课后练习

1. 基础练习：

• 编写一个程序，使用 for 循环和 range () 函数生成并输出 1 到 100 的所有整数。

• 编写一个程序，遍历字符串 “Hello, World!”，并输出其中的每个字符。

1. 进阶练习：

• 编写一个程序，计算并输出 1 到 100 的和。

• 编写一个程序，打印所有三位数中的水仙花数（即一个三位数等于其各位数字的立方和）。

1. 挑战练习：

- 编写一个程序，生成并打印以下数字金字塔：

1

121

12321

1234321

123454321

• 编写一个程序，打印以下图案：

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

通过这些练习，你将能够更好地掌握 Python 的 for 循环和 range () 函数，为后续的学习打下坚实的基础。如果你在练习过程中遇到任何问题，请随时提问。