Skip to content

第 6 章:循环 ​

本章承接第 5 章的条件判断——循环里的"什么时候停"就是一个条件。学会循环后,程序就有了处理大量重复工作的能力,为后续章节的批量数据处理铺垫。

本章能学到什么 ​

  • 用 while 和 for 让计算机做重复劳动
  • 循环与数学里的数列:等差、等比数列都能用循环生成
  • range 的用法与"终点不算"的惯例
  • Python 的 for 与 C++ 三段式 for 的对照
  • break 提前退出,continue 跳过本次
  • 循环嵌套:打印九九乘法表
  • 死循环是怎么发生的,如何避免

场景:从 1 加到 100 ​

数学课上有个著名故事:老师让全班算 1+2+3+⋯+100,小高斯很快给出答案 5050。他的办法是配对:1+100=101,2+99=101,共 50 对,所以

1+2+⋯+100=(1+100)×1002=5050

推广到任意 n:

1+2+⋯+n=n(n+1)2

不用高斯的巧法,程序会怎么算?以目前的知识,只能一行行写:

python
total = 0
total = total + 1
total = total + 2
total = total + 3
# ……还要写 97 行

加到 100 要写 100 行,加到一万要写一万行。人不能这么干活,但机器最擅长这种重复——只需要告诉它"重复的规律"是什么。观察上面的代码:每一行都是"把下一个数加进 total"。这就是循环要表达的东西。

while:只要条件成立就重复 ​

while 的意思是"只要……就……"。只要 i 还没超过 100,就把 i 加进总和,并让 i 前进一格:

python
total = 0
i = 1

while i <= 100:
    total += i    # 等价于 total = total + i
    i += 1        # 等价于 i = i + 1

print(total)
text
5050

和高斯的答案一致。while 的写法和 if 很像:条件后面带冒号,缩进的语句是要重复的内容。区别是:if 执行一次就结束,while 执行完会回到条件再检查一次,条件还成立就再执行,直到条件不成立为止。

这个循环里 i += 1 至关重要。少了它,i 永远是 1,条件永远成立——程序永远停不下来,这就是本章最后要讲的死循环。

while 特别适合"转到某个状态出现为止"的场合。比如猜数字游戏:只要没猜中,就一直问。

python
secret = 42
guess = 0

while guess != secret:    # 没猜中就继续
    guess = int(input("猜一个数:"))
    if guess < secret:
        print("小了")
    elif guess > secret:
        print("大了")

print("猜对了!")

一次可能的运行:

text
猜一个数:50
大了
猜一个数:30
小了
猜一个数:42
猜对了!

注意循环次数事先不知道——玩家可能三次猜中,也可能十次。这正是 while 的主场。

for 与 range:从序列里逐个取数 ​

"重复 N 次"这种模式太常见了,Python 给了它一个专门写法:

python
total = 0

for i in range(1, 101):
    total += i

print(total)
text
5050

读法:range(1, 101) 生成一个从 1 到 100 的数列,for i in ... 把数列里的数逐个取出,每次取出的数叫 i,执行一遍缩进的内容。数列取完,循环自动结束。

range 的用法:

写法生成的数列说明
range(5)0, 1, 2, 3, 4从 0 开始,共 5 个
range(1, 6)1, 2, 3, 4, 5起点到终点
range(2, 11, 2)2, 4, 6, 8, 10第三个数是步长

终点不算,这是 Python 的惯例:range(1, 101) 包含 1,不包含 101,最后一个数是 100。第一次写很容易少循环一次。亲手验证一下:

python
for i in range(1, 6):
    print(i, end=" ")
print()
text
1 2 3 4 5

for 和 while 能做的事完全一样,只是分工不同:次数明确的循环用 for 更紧凑,"一直转到某个状态出现"的循环用 while 更自然。

循环与数列 ​

数学里的数列,几乎都能用一个循环生成。数列的"规律"就是 range 的"步长":

数列规律range 写法
1,2,3,…,100每次加 1range(1, 101)
1,3,5,…,99每次加 2range(1, 100, 2)
2,4,8,…,1024每次乘 2range 办不到,用 while

比如打印等比数列 2,4,8,… 直到超过 1000。乘法规律超出 range 的能力,换 while:

python
n = 2
while n <= 1000:
    print(n, end=" ")
    n *= 2
print()
text
2 4 8 16 32 64 128 256 512

等差数列的第 n 项公式 an=a1+(n−1)d,range 里那个"每次加 d"的步长就是公差 d。循环不是新东西,它是数列规律的另一种写法。

累加与累乘:阶乘 ​

求和是"累加",乘法的版本是"累乘"。数学里的阶乘 n!=1×2×3×⋯×n 就是典型的累乘:

python
fact = 1    # 累乘从 1 开始,不是 0

for i in range(1, 6):
    fact *= i

print(fact)
text
120

两个细节值得对照:累加的起点是 0(加 0 不影响结果),累乘的起点是 1(乘 1 不影响结果);累加用 +=,累乘用 *=。起点误写成 0,阶乘结果就永远是 0——这是初学者常踩的坑。

循环次数怎么算 ​

循环跑了多少圈,其实就是数列"有多少项"的问题。等差数列的项数公式:

项数=末项−首项公差+1

对照循环:range(1, 100, 2) 的首项是 1,末项是 99,公差是 2,项数 (99−1)÷2+1=50——正好跑 50 圈。这就是动手实验第 1 题里"前 50 个奇数之和"中 50 的来历。会算项数,就能在运行前预判循环次数,也能检查 range 的参数有没有写错。

break 与 continue ​

循环中途需要两种"打断":

关键字作用类比
break立刻结束整个循环下课铃:全班放学
continue跳过本轮剩下的内容,直接开始下一轮跳过这道题,做下一道

例子:打印 1 到 10,但跳过 3 的倍数。

python
for i in range(1, 11):
    if i % 3 == 0:
        continue    # 3 的倍数:跳过本轮
    print(i, end=" ")
print()
text
1 2 4 5 7 8 10

如果把 continue 换成 break,遇到 3 就直接结束整个循环,输出只剩 1 2。一个是"跳过当前",一个是"全部结束",一字之差,结果完全不同。

循环嵌套:九九乘法表 ​

循环里可以再放循环,像钟表:内层是分针,外层是时针。分针转完一整圈,时针才走一格。

打印九九乘法表:外层循环负责行(第 i 行),内层循环负责这一行里的每一列(第 j 列)。

python
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i * j}", end="\t")
    print()    # 一行打完,换行
text
1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
……(中间略)
1×9=9   2×9=18  ……      9×9=81

f"{j}×{i}={i * j}" 是第 3 章见过的 f-string,把变量的值嵌进文字。\t 是制表符,让各列对齐。end="\t" 表示打印完不换行、用制表符收尾。

注意内层循环的写法是 range(1, i + 1):第几行就打几列,所以乘法表是三角形。外层每走一轮,内层都要从头到尾完整跑一遍——这正是嵌套的含义:第 i 行打印的过程中,j 从 1 一直数到 i。

嵌套练习:星号三角形 ​

乘法表把"表格"打印出来了,嵌套循环还能"画图"。打印一个五行高的星号三角形:

python
for i in range(1, 6):
    for j in range(1, i + 1):
        print("*", end="")
    print()
text
*
**
***
****
*****

第 i 行打印 i 颗星——内层循环的上限跟着外层变量走,这是这类图形的共同钥匙。改成 range(1, 7 - i),三角形就倒过来。打印图形的本质是把"第几行画几个"翻译成循环参数。

死循环:最常见的坑 ​

条件永远成立,循环就永远不停:

python
while True:
    print("停不下来了")

屏幕上会疯狂刷字。别慌,按 Ctrl + C 可以强行终止程序。

死循环几乎都是"忘记更新循环变量"造成的。写一个 while 循环时,先问自己两个问题:条件里的变量,在循环体里有没有变化?变化的方向是不是朝着"条件最终不成立"?两个都答"是",循环才会停。

有时死循环是故意写的,比如游戏主循环"只要玩家没退出就一直运行"——但这种循环里一定藏着某个 break 出口。

for 还是 while:怎么选 ​

两个循环能力等价,选择看意图:

场景推荐理由
次数事先确定for + range数列写在一行里,一眼看清
转到某个状态为止while条件本身就是"状态到了没有"
一直运行直到用户退出while True + break出口写在循环体里更自然

判断依据是一句话:能用"重复 N 次"描述的用 for,只能用"直到……为止"描述的用 while。猜数字事先不知道次数,所以用 while;九九乘法表正好九行,所以用 for。

累加器:循环里最常用的套路 ​

本章反复出现一个模式:循环前准备一个变量(total = 0、fact = 1),循环里不断更新它(total += i、fact *= i),循环结束后使用它。这个模式叫累加器。它像存钱罐:循环一圈投一次币,最后打开数总数。

认出这个模式后,"求和、求积、计数、找最大"都是同一套骨架,只是换投币的动作:计数是每次投 +1,找最大是每次比较后决定是否替换罐子里的数。后续章节处理成批数据时,这个套路会一再出现。

常见错误自查表 ​

现象可能原因
程序卡住、疯狂刷屏死循环:循环变量没有更新
循环少执行一次忘了 range 的终点不算
IndentationError循环体的缩进不一致
break 后循环还在继续混淆了 break 和 continue

【跨语言对照】 ​

本质问题:让计算机重复 N 次,语言要回答两个问题——循环变量从哪里来?什么时候停?

各自做法:Python 的 for 是"从序列里逐个取东西",range(1, 101) 负责生成 1 到 100 这个序列,取完自动停。C++ 的三段式 for 把三件事都摆在明处:起点、停止条件、步进,全部由程序员写清楚。

同一个求和,两边的等价代码:

python
total = 0
for i in range(1, 101):
    total += i
print(total)
cpp
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
cout << sum << endl;

两边输出一致:

text
5050

写法差异对照:

对照项PythonC++
循环 100 次for i in range(1, 101)for (int i = 1; i <= 100; i++)
循环变量来源range 生成的序列逐个取出自己声明,自己递增
停止方式序列取完自动结束每轮检查 i <= 100
终点包含性range(1, 101) 含 100,不含 101<= 100,包含 100
break / continue有有,用法相同

为什么设计不一样:Python 观察到绝大多数循环的意图是"把一堆东西逐个处理一遍",于是直接把"遍历"做成语言的核心动作,for i in ... 读出来就像一句英语。C++ 让循环的底层机制完全透明——递增多少、什么时候检查条件、甚至同时操作多个变量,都能写在那三个格子里。灵活,但每一部分都要自己操心。一个追求表达的直接,一个追求控制感。九九乘法表在 《C++ 从入门到精通》第 6 章 有等价的 C++ 版本,两边输出完全一致,建议对照着读。

动手实验 ​

  1. 用 for 循环计算 1+3+5+⋯+99(100 以内的奇数之和),并和数学公式对照:第 n 个奇数是 2n−1,前 50 个奇数之和是 502。
💡 查看答案
python
total = 0
for i in range(1, 100, 2):
    total += i
print(total)
text
2500

502=2500,程序结果与公式一致。range(1, 100, 2) 让步长变成 2,正好走遍所有奇数。

  1. 用 while 循环找出最小的、满足"平方大于 1000"的整数 n,输出 n 和它的平方。
💡 查看答案
python
n = 1
while n * n <= 1000:
    n += 1
print(n, n * n)
text
32 1024

312=961 不超过 1000,322=1024 首次超过,所以答案是 32。

  1. 改造九九乘法表,让它只打印"乘积不超过 30"的格子(提示:在内层循环里用 break)。
💡 查看答案
python
for i in range(1, 10):
    for j in range(1, i + 1):
        if i * j > 30:
            break    # 这一行后面的格子都超了,直接结束本行
        print(f"{j}×{i}={i * j}", end="\t")
    print()
text
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×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30
1×7=7   2×7=14  3×7=21  4×7=28
1×8=8   2×8=16  3×8=24
1×9=9   2×9=18  3×9=27

内层循环里 j 是递增的,乘积一旦超过 30,后面的格子必然也超过,所以 break 是安全的。

  1. 把星号三角形倒过来打印:第一行 5 颗星,每往下一行少一颗,最后一行 1 颗。
💡 查看答案
python
for i in range(5, 0, -1):
    for j in range(1, i + 1):
        print("*", end="")
    print()
text
*****
****
***
**
*

range(5, 0, -1) 用负步长倒着数:5、4、3、2、1。终点 0 照例不算。