Python 循环语句

发表于2025-10-27|更新于2025-10-29|编程Python 教程

|总字数:11.1k|阅读时长:39分钟|浏览量:

Python 循环语句

在前面的学习中，我们写的代码大多是一行接一行地顺序执行，就像我们一步一步地走路一样，做完一件事再做下一件

但是，如果我们需要做很多重复的事情，比如打印 100 遍 “Hello World”，或者计算 1 到 100 的总和，难道我们要把相同的代码写 100 遍吗？那会非常的麻烦！

但是，别担心，编程之所以强大，就是因为它能让计算机帮我们做重复的工作。循环语句就是实现这种重复的魔法

什么是循环？

简单说，循环就是让一部分代码按照我们设定的条件，重复执行多次的结构。

你可以这么设想：

你想打印 5 遍 “我爱 Python！”。如果没有循环，你可能需要写 5 行 print("我爱 Python！")。有了循环，几句话就能搞定
游戏里角色的移动、敌人的刷新，背后都离不开循环的控制。

循环是如何工作的？

我们可以把循环看成一个检查点和一个执行区：

来到检查点：看看现在是不是该执行执行区里的代码。
如果条件允许，比如：我还没打印够 5 遍，就进入执行区执行代码。
执行完一次后，再次回到检查点。
如果条件不允许了，比如：我已经打印够 5 遍了，就离开循环，继续执行循环后面的代码

下面是一个简单的程序框图，展示了循环的一般工作流程：

Python 中的循环类型

Python 主要提供了两种类型的循环语句，让我们能应对不同的重复场景：

1. `while` 循环

特点：只要给定的条件为真（True），就会一直重复执行循环体里的代码。
就像：“只要天还没黑，我就继续玩。” 这里“天还没黑”就是条件，“继续玩”就是循环体。

2. `for` 循环

特点：通常用于遍历序列中的每个元素，就比如列表和字符串，或者执行固定次数的循环。
就像：“我有一个水果篮子，里面有苹果、香蕉、橘子，我要把它们一个一个拿出来吃掉。” 这里“水果篮子”就是一个序列，“一个一个拿出来吃掉”就是循环体。

3. 嵌套循环

特点：在一个循环的内部，再放一个循环。这就像俄罗斯套娃一样。
用途：处理更复杂的重复任务，比如打印一个矩阵

循环控制语句

有时候，我们不希望循环严格按照条件判断 -> 执行的固定流程走。比如，我们可能想提前结束整个循环，或者跳过当前这次循环剩下的部分，直接开始下一次

Python 提供了几种循环控制语句来帮助我们更灵活地控制循环：

1. `break` 语句

作用：立即终止当前的整个循环，并且跳出循环体，不再执行后续的循环迭代。
就像：你在看书，突然电话响了，你不得不立刻停止看书，不管看到第几页，去接电话。

2. `continue` 语句

作用：立即终止当前这一次的循环迭代，跳过循环体中 continue 后面剩余的语句，直接进入下一次循环的条件判断。
就像：你在吃一串葡萄，吃到一颗特别酸的，你会把这颗吐掉，然后继续吃下一颗，而不是把整串葡萄都扔了。

3. `pass` 语句

作用：**pass 是一个空语句，它什么也不做**。主要是为了在语法上需要一条语句，但我们暂时不想写具体代码的时候使用，用来保持程序结构的完整性。
就像：你在日程本上写下“明天要学习循环”，但具体怎么学还没想好，先记下来占个位置。

好了，到这里，相信你已经对 Python 循环有了一个基本的概念性了解。接下来的内容，我会详细学习每一种循环和控制语句的具体用法

Python While 循环语句

while 循环是 Python 中最简单也是最常用的循环类型之一。它的核心思想非常朴素：

只要一个给定的条件成立（为真），就不断重复执行一段代码（循环体）。一旦条件不成立（为假），就停止循环，继续执行循环后面的代码。

1.1 `while` 循环的基本结构

while 条件表达式:
    循环体语句 (当条件为 True 时执行)
    ... (可以有多行语句)
# 循环结束后，执行这里的代码

**while**：这是 Python 的关键字，告诉 Python 接下来是一个 while 循环。
条件表达式：一个会被计算为 True 或 False 的表达式。就像一个守门人，决定循环是否继续。
**冒号 :**：表示条件表达式的结束，以及循环体的开始。
循环体语句：这部分是当条件为 True 时，会被重复执行的代码。循环体必须缩进（通常是 4 个空格），这是 Python 区分代码块的方式。

1.2 `while` 循环是如何工作的？

执行步骤：

首先，检查 while 后面的“条件表达式”。
如果条件为 True：
- 执行缩进的“循环体语句”。
- 执行完一遍循环体后，再次回到步骤 1 检查条件。
如果条件为 False：
- 跳过“循环体语句”，退出 while 循环。
- 继续执行 while 循环结构之后的代码。

1.3 第一个 `while` 循环实例

让我们看一个简单的例子，用 while 循环打印从 0 到 8 的数字：

count = 0  # 初始化一个计数器
while count < 9:  # 条件：只要 count 小于 9，就执行循环体
    print("The count is:", count)
    count = count + 1  # 计数器加 1，非常重要！否则条件永远为 True
print("Good bye!")  # 循环结束后执行

运行结果：

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

代码解析：

count = 0：我们先创建了一个变量 count 并初始化为 0，用作计数器。
while count < 9:：条件是 count 小于 9。一开始 count 是 0，条件为 True。
print("The count is:", count)：打印当前的 count 值。
count = count + 1：这是非常关键的一步！它让 count 的值每次增加 1。如果没有这一步，count 永远是 0，条件 count < 9 永远为 True，循环就会永远执行下去，即无限循环
当 count 增加到 9 时，count < 9 变为 False，循环停止。
最后打印 "Good bye!"。

2. 循环控制：`break` 和 `continue`

有时候，我们希望在循环体内部根据某些条件来改变循环的正常流程。Python 提供了两个重要的关键字来实现这一点：break 和 continue。

2.1 `break` 语句：立即终止循环，跳出！

break 语句的作用是：立即终止当前循环，并且跳出整个循环体，不再执行循环体中 break 后面的语句，也不再回到条件判断，直接执行循环后面的代码。

设想一个场景，你在看书，突然火警响了，你会立刻停止看书，跑出房间

实例：找到第一个偶数就停止

i = 1
while i < 10:
    if i % 2 == 0:  # 如果 i 是偶数
        print("找到第一个偶数:", i)
        break  # 立即终止循环，跳出
    i = i + 1
print("循环结束")

运行结果：

1 2	找到第一个偶数: 2 循环结束

实例：从 1 数到 10，然后停止

i = 1
while True:  # 条件永远是 True，理论上是无限循环
    print(i)
    i = i + 1
    if i > 10:  # 当 i 大于 10 时
        break  # 跳出循环，终止无限循环
print("数完了！")

运行结果：

这里 while True: 会创建一个无限循环，但我们用 break 语句在适当的时候终止了它。

2.2 `continue` 语句：跳过本次循环剩余部分，直接开始下一次循环

continue 语句的作用是：立即终止当前这一轮的循环，跳过循环体中 continue 后面剩余的语句，直接回到循环的条件判断处，准备开始下一次循环（如果条件仍然成立）。

这就像你在吃葡萄，吃到一颗坏的，你会把这颗坏的吐掉，跳过它，continue，然后接着吃下一颗

**实例

i = 0
while i < 10:
    i = i + 1
    if i % 2 == 0:  # 如果 i 是偶数
        continue  # 跳过下面的 print，直接进入下一次循环判断
    print(i)  # 只有当 i 是奇数时才会执行到这里

运行结果：

解释：当 i 是偶数时，continue 语句让程序跳过了 print(i)，直接回到 while 条件判断。

3. 无限循环：停不下来的循环

如果 while 循环的条件表达式永远为 True，那么循环就会一直执行下去，永不停止，这就是无限循环。

不小心写出无限循环是初学者常见的错误，通常是因为忘记在循环体中修改条件表达式里的变量（比如忘记 count = count + 1）。

3.1 一个简单的无限循环例子

var = 1
while var == 1:  # var 永远是 1，条件永远为 True
    num = input("请输入一个数字 (输入 'q' 退出): ")  # Python 3 使用 input()，Python 2 用 raw_input()
    if num == 'q':
        break  # 如果用户输入 'q'，就跳出循环
    print("你输入的数字是:", num)

运行结果（示例）：

请输入一个数字 (输入 'q' 退出): 123
你输入的数字是: 123
请输入一个数字 (输入 'q' 退出): 456
你输入的数字是: 456
请输入一个数字 (输入 'q' 退出): q

这个例子中，我们用 break 语句给了用户一个退出无限循环的途径。

3.2 如何终止不小心写出的无限循环？

如果你的程序陷入了无限循环，可以：

在大多数 Python IDE（如 PyCharm, VS Code）中，可以点击停止按钮。
在命令行或终端中运行时，可以按 Ctrl + C 组合键来强制终止程序。

4. `while ... else` 语句

Python 的 while 循环还有一个特殊的语法：可以和 else 子句一起使用。

语法：

while 条件表达式:
    循环体语句
else:
    当条件表达式变为 False，且循环是正常结束，即，不是通过 'break' 语句跳出，时执行的语句

作用：else 子句中的代码块，会在 while 循环的条件变为 False，并且循环体是正常执行完毕.即不是因为执行了 break 语句而退出

实例

count = 0
while count < 5:
    print(count, "小于 5")
    count = count + 1
else:
    print(count, "不再小于 5 (循环正常结束)")

运行结果：

0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 不再小于 5 (循环正常结束)

如果循环中出现 break

count = 0
while count < 5:
    print(count, "小于 5")
    count = count + 1
    if count == 3:
        break  # 当 count 等于 3 时，强行跳出循环
else:
    print(count, "不再小于 5 (循环正常结束)")  # 这行不会被执行！

运行结果：

1
2
3

0 小于 5
1 小于 5
2 小于 5

可以看到，因为循环是通过 break 结束的，else 子句没有执行。

5. 简单语句组

如果 while 循环的循环体中只有一条语句，你可以将这条语句与 while 写在同一行。这只是一种简写形式，不影响功能。

语法：

1	while 条件表达式: 一条语句

实例：

flag = 1
while flag: print(" flag 为 True，循环继续...")  # 这是一个无限循环，因为 flag 始终为 1 (True)

# 注意：按 Ctrl + C 停止

但这种方式不推荐，虽然简洁，但如果循环体逻辑稍微复杂一点，这种写法会降低代码的可读性。对于初学者，建议还是使用标准的缩进形式

For 循环语句

for 循环是 Python 中另一种非常强大的循环结构。与 while 循环侧重于，当条件满足时就一直做不同，for 循环更侧重于对序列中的每个元素，都做一次。

简单说，for 循环最擅长的就是遍历——即依次访问序列中的每一个元素

2.1 `for` 循环的基本结构

for 变量 in 序列:
    循环体语句 (对序列中的每个元素执行)
    ... (可以有多行语句)
# 循环结束后，执行这里的代码

**for**：Python 关键字，标记一个 for 循环的开始。
变量：也叫“迭代变量”或“循环变量”。在每一次循环中，这个变量会被赋值为序列中的下一个元素。
**in**：Python 关键字，用于连接变量和序列，表示“在…之中”。
序列：一个包含多个元素的对象，例如字符串、列表、元组等。for 循环会依次取出序列中的元素。
**冒号 :**：表示序列的结束，以及循环体的开始。
循环体语句：对序列中的每个元素要执行的操作。循环体必须缩进（通常是 4 个空格）。

2.2 `for` 循环是如何工作的？

执行步骤：

从序列中取出第一个元素。
如果序列中还有元素,即没有取完
- 将取出的元素赋值给“变量”。
- 执行缩进的循环体语句（也就是使用当前变量的值）。
- 执行完一遍循环体后，回到步骤 1 取下一个元素。
如果序列中没有元素了，即所有元素都已处理完毕
- 退出 for 循环。
- 继续执行 for 循环后面的代码。

2.3 实例1：遍历字符串

字符串是字符的序列。我们可以用 for 循环遍历字符串中的每个字符。

# 实例1：遍历字符串
message = "Python"
for char in message:  # char 依次是 'P', 'y', 't', 'h', 'o', 'n'
    print("当前字母:", char)
print("循环结束!")

运行结果：

当前字母: P
当前字母: y
当前字母: t
当前字母: h
当前字母: o
当前字母: n
循环结束!

2.4 实例2：遍历列表

列表是 Python 中最常用的序列类型之一，可以包含各种类型的元素。

# 实例2：遍历列表
fruits = ['香蕉', '苹果', '芒果']
for fruit in fruits:  # fruit 依次是 '香蕉', '苹果', '芒果'
    print('当前水果:', fruit)
print("水果都吃完啦！")

运行结果：

当前水果: 香蕉
当前水果: 苹果
当前水果: 芒果
水果都吃完啦！

2.5 通过序列索引进行遍历，配合 `range()` 和 `len()`

有时候，我们不仅需要元素的值，还需要知道元素在序列中的位置。这时，可以使用 range() 函数配合 len() 函数来生成索引序列，然后通过索引访问元素。

**len(序列)**：返回序列的长度，即元素的个数。
**range(stop)**：生成一个从 0 开始，到 stop-1 结束的整数序列。例如 range(5) 生成 0, 1, 2, 3, 4。
**range(start, stop)**：生成从 start 开始，到 stop-1 结束的整数序列。

实例3：使用索引遍历列表

fruits = ['香蕉', '苹果', '芒果']
# len(fruits) 是 3，range(len(fruits)) 生成 0, 1, 2
for index in range(len(fruits)):
    print('索引:', index, '，水果:', fruits[index])  # fruits[index] 通过索引访问元素

运行结果：

1
2
3

索引: 0 ，水果: 香蕉
索引: 1 ，水果: 苹果
索引: 2 ，水果: 芒果

这种方式类似于其他语言中常见的 for (i=0; i<N; i++) 形式。

2.6 `for` 循环中的 `break` 和 `continue`

和 while 循环一样，for 循环也可以配合 break 和 continue 这两个控制语句来改变循环的执行流程。

**break**：立即终止整个 for 循环，跳出循环体。
**continue**：跳过当前这次循环中 continue 后面的语句，直接开始下一次循环（取下一个元素）。

实例4：break 示例 - 找到 ‘苹果’ 就停止

fruits = ['香蕉', '苹果', '芒果', '橘子']
for fruit in fruits:
    if fruit == '苹果':
        print("找到了苹果！")
        break  # 找到后立即退出循环
    print("当前水果:", fruit)

运行结果：

1 2	当前水果: 香蕉找到了苹果！

芒果和橘子没有被打印，因为循环已经被 break 终止了

实例5：continue 示例 - 跳过 ‘苹果’

fruits = ['香蕉', '苹果', '芒果', '橘子']
for fruit in fruits:
    if fruit == '苹果':
        continue  # 跳过当前水果，直接进行下一次循环
    print("当前水果:", fruit)

运行结果：

1
2
3

当前水果: 香蕉
当前水果: 芒果
当前水果: 橘子

（’苹果’ 被 continue 跳过了。）

2.7 `for ... else` 语句：循环正常结束时执行的操作

与 while ... else 类似，for 循环也可以搭配 else 子句。

语法：

for 变量 in 序列:
    循环体语句
else:
    当序列中的所有元素都被遍历完毕，且循环是正常结束，即，不是通过 'break' 语句跳出时执行的语句

作用：else 子句中的代码块，会在 for 循环完整地遍历了序列中的所有元素，并且没有因为执行 break 语句而提前退出的情况下执行。

实例6：判断列表中是否有负数，无 break 则 else 执行

numbers = [1, 3, 5, 7, 9]
for num in numbers:
    if num < 0:
        print("发现负数:", num)
        break
else:
    print("列表中没有负数。")  # 因为没有 break，所以会执行

运行结果：

列表中没有负数。

实例7：判断列表中是否有负数，有 break 则 else 不执行

numbers = [1, -3, 5, 7, 9]
for num in numbers:
    if num < 0:
        print("发现负数:", num)
        break
else:
    print("列表中没有负数。")  # 因为有 break，所以不会执行

运行结果：

发现负数: -3

经典应用：判断质数

下面是一个更实用的例子，用 for ... else 结构判断一个数是否为质数：

num = 17  # 我们要判断的数

if num <= 1:
    print(num, "不是质数")
else:
    # 检查从 2 到 num-1 的数是否能整除 num
    for i in range(2, num):
        if num % i == 0:  # 如果能整除，说明不是质数
            print(num, "等于", i, "*", num//i)
            print(num, "不是质数")
            break
    else:
        # 如果上面的循环没有找到能整除的数（即没有执行 break）
        print(num, "是一个质数")

运行结果：

17 是一个质数

如果把 num 改成 15：

1 2	15 等于 3 * 5 15 不是质数

2.8 更多实例：用 `for` 循环打印图案

for 循环非常适合用来打印各种有规律的文本图案，比如三角形、矩形、菱形等。这通常会用到嵌套 for 循环。即，一个 for 循环里面再包含一个或多个 for 循环

实例8：打印一个 5x5 的矩形星号 (*)

# 打印矩形
rows = 5  # 行数
cols = 5  # 列数

for i in range(rows):          # 外层循环控制行数
    for j in range(cols):      # 内层循环控制每行的列数
        print("*", end=" ")    # 打印一个星号和一个空格，end="" 表示不换行
    print()  # 一行打印完后换行

运行结果：

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

实例9：打印一个直角三角形

# 打印直角三角形 (靠右对齐)
rows = 5
for i in range(1, rows + 1):  # i 从 1 到 5 (行数)
    # 先打印 (rows - i) 个空格，再打印 i 个星号
    for j in range(rows - i):
        print(" ", end=" ")
    for k in range(i):
        print("*", end=" ")
    print()  # 换行

运行结果：

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

这些图案打印练习能很好地帮助你理解循环的控制流程，特别是嵌套循环。

嵌套循环

一、什么是循环嵌套？

可以类比为，你要做多层嵌套的俄罗斯套娃，或者盖一栋有多层房间的楼房。在编程里，循环嵌套就是在一个循环的“身体里”再放进另一个循环。就像你写作业时，先按科目循环，比如先做数学、再做语文……每个科目里又按题目循环，第一题、第二题……

Python 里不管是 for 循环还是 while 循环，都能互相嵌套。比如：

for 里套 for
for 里套 while
while 里套 for
while 里套 while

二、循环嵌套的基本语法

（一）for 循环嵌套 for 循环

for 外层变量 in 外层序列:
    # 外层循环的操作
    for 内层变量 in 内层序列:
        # 内层循环的操作
    # 外层循环后续操作（内层循环结束后执行）

（二）while 循环嵌套 while 循环

外层条件 = 初始值
while 外层条件 满足:
    # 外层循环的操作
    内层条件 = 初始值
    while 内层条件 满足:
        # 内层循环的操作
        内层条件 更新  # 别忘更新，否则无限循环！
    外层条件 更新  # 别忘更新，否则无限循环！

（三）混合嵌套（比如 for 套 while，while 套 for）

原理和上面一样，只要记住内层循环要完全“包裹”在外层循环的缩进块里，Python 靠缩进来区分不同层级的循环体~

三、循环嵌套如何执行？

看个简单例子：打印一个 3 行 4 列的星号矩形

for 行 in range(3):  # 外层循环控制“行”，执行 3 次（行号 0,1,2）
    for 列 in range(4):  # 内层循环控制“列”，每行执行 4 次（列号 0,1,2,3）
        print("*", end=" ")  # 打印星号，end=" " 表示不换行
    print()  # 内层循环结束后，换行准备下一行

执行流程拆解：

外层循环第 1 次（行=0）：
- 进入内层循环，列从 0 到 3，依次打印 * ，所以第一行是 * * * *
- 内层循环结束后，执行 print() 换行
外层循环第 2 次（行=1）：
- 内层循环再执行 4 次，打印第二行 * * * *
- 换行
外层循环第 3 次（行=2）：
- 内层循环再执行 4 次，打印第三行 * * * *
- 换行
  最终输出：
  1
  2
  3
  * * * *
  * * * *
  * * * *

四、实战：用嵌套循环找 2~100 的素数

素数是指只能被 1 和它本身整除的大于 1 的整数。比如 2、3、5、7 是素数，4、6不是

先暂停一下，思考思考，再看下面的内容！！！

思路：

外层循环 i 从 2 遍历到 99（因为要找 2~100 的数）。
对每个 i，用内层循环 j 去试除：从 2 开始，直到 j ≤ i/j.这样可以减少计算次数，比如 i=100 时，j 只需要试到 10 就行，因为 10*10=100
如果 i % j == 0，说明 i 能被 j 整除，不是素数，立刻 break 内层循环。
如果内层循环跑完了都没找到能整除的 j.即,内层循环是自然结束，不是被 break 打断的），说明 i 是素数，打印出来

代码实现（while 套 while）：

i = 2
while i < 100:  # 外层循环：i 从 2 到 99
    j = 2
    # 内层循环：j 从 2 开始，直到 j > i/j（这样减少计算量）
    while j <= (i / j):
        if i % j == 0:  # 能整除，说明不是素数
            break  # 跳出内层循环，不用再试了
        j += 1  # 试除的数 +1
    # 内层循环结束后，判断是“自然结束”还是被 break 打断
    if j > (i / j):  # 如果自然结束，说明没找到能整除的 j，是素数
        print(i, "是素数")
    i += 1  # 外层循环的 i +1，继续下一个数
print("Good bye!")

代码执行逻辑拆解：

拿 i=9 举例：

外层循环 i=9，进入内层循环 j=2。
检查 j <= 9/j → 2 ≤ 4.5 → 成立。
检查 9%2 → 余 1，不能整除，所以 j +=1 → j=3。
再检查 j <= 9/j → 3 ≤ 3 → 成立。
检查 9%3 → 余 0，能整除 → break 内层循环。
内层循环被 break 打断，所以不会执行 if j > i/j 里的打印，i=9 不是素数。

再拿 i=7 举例：

外层循环 i=7，内层循环 j=2。
j <=7/2 → 2 ≤ 3.5 → 成立。
7%2=1 → 不能整除，j=3。
检查 j <=7/3 → 3 ≤ 2.333… → 不成立！所以内层循环自然结束
此时 j=3 > 7/3≈2.333 → 满足条件，打印 7 是素数。

五、循环嵌套的注意事项

缩进要清晰：内层循环必须比外层循环多缩进（通常 4 个空格，这是第N次强调了），否则 Python 会分不清哪层是哪层。
小心无限循环：内层和外层循环都要记得更新循环条件！比如外层 while 里的变量要递增，内层 while 里的变量也要递增，否则容易无限循环。
性能问题：嵌套层数越多，执行次数呈指数级增长，比如 3 层循环，每层循环 10 次，总执行次数是 10×10×10=1000 次。如果嵌套太多，程序可能会很慢，实际开发要谨慎

六、拓展练习：用 for 套 for 实现素数判断

把上面的 while 套 while 改成 for 套 for，感受不同循环嵌套的写法。老规矩，先自己写，再看参考代码

for i in range(2, 100):  # 外层 for 循环，i 从 2 到 99
    is_prime = True  # 先假设 i 是素数
    # 内层 for 循环：j 从 2 到 int(i**0.5)（和 j <= i/j 效果一样，更简洁）
    for j in range(2, int(i**0.5) + 1):
        if i % j == 0:  # 能整除，不是素数
            is_prime = False
            break  # 跳出内层循环
    if is_prime:  # 如果还是 True，说明是素数
        print(i, "是素数")
print("Good bye!")

这里用 range(2, int(i**0.5)+1) 代替了 while j <= i/j，逻辑更简洁。原理是一样的，只要试除到平方根就够了

break 语句

一、break 是做什么的？

就像你在玩闯关游戏，每一关是循环里的一次迭代。当你触发 break，比如，找到关键道具、触发特殊条件，不管循环有没有执行完，都会立刻终止当前所在的那一层循环，直接跳出循环体，去执行循环后面的代码

简单说，break 就是循环的紧急停止按钮，让循环提前结束

二、break 的基本语法

break 是 Python 的关键字，单独使用，不需要加括号或参数，写在循环体中

（一）在 for 循环中用 break

for 变量 in 序列:
    代码块1
    if 条件:
        break  # 满足条件时，立刻终止整个 for 循环
    代码块2
# 循环结束后，执行这里的代码

（二）在 while 循环中用 break

while 条件:
    代码块1
    if 条件:
        break  # 满足条件时，立刻终止整个 while 循环
    代码块2
    # 记得更新 while 的条件变量，否则容易无限循环！
# 循环结束后，执行这里的代码

三、break 如何工作？

以 for 循环为例：

四、实例演示：break 在 for 和 while 中怎么用？

（一）实例1：for 循环中遇到 ‘h’ 就停止

for letter in 'Python':
    if letter == 'h':
        break  # 当字母是 'h' 时，终止整个 for 循环
    print('当前字母:', letter)
print("循环结束，继续执行后面的代码～")

执行结果：

当前字母: P
当前字母: y
当前字母: t
循环结束，继续执行后面的代码～

解释：for 循环原本要遍历 ‘P’,’y’,’t’,’h’,’o’,’n’，但当遍历到 ‘h’ 时，break 触发，循环直接终止，所以后面的 ‘o’、’n’ 没机会被处理。

（二）实例2：while 循环中变量到 5 就停止

var = 10
while var > 0:
    print('当前变量值:', var)
    var = var - 1  # 变量递减
    if var == 5:
        break  # 当 var 减到 5 时，终止 while 循环
print("Good bye!")

执行结果：

当前变量值: 10
当前变量值: 9
当前变量值: 8
当前变量值: 7
当前变量值: 6
Good bye!

解释：while 条件是 var > 0，原本要从 10 减到 1。但当 var 减到 5 时，break 触发，循环终止，所以 4、3、2、1 不会被打印。

五、break 在嵌套循环中的表现

如果是嵌套循环，比如 for 套 for，while 套 while，或者混合嵌套，break 只会终止它所在的那一层循环，不会影响外层循环

实例3：嵌套 for 循环中，break 只终止内层循环

# 外层循环控制行
for row in range(3):
    # 内层循环控制列
    for col in range(4):
        if col == 2:  # 当列数到 2 时，终止内层循环
            break
        print(f"({row},{col}) ", end="")
    print()  # 内层循环结束后，换行
print("外层循环也结束啦～")

执行结果：

(0,0) (0,1) 
(1,0) (1,1) 
(2,0) (2,1) 
外层循环也结束啦～

解释：

外层循环 row 从 0 到 2（共 3 行）。
内层循环 col 从 0 到 3，但每次到 col=2 时，break 终止当前这一层循环，所以每行只打印 col=0 和 col=1。
内层循环终止后，回到外层循环，继续下一行

六、break 的常见使用场景

提前终止循环：当已经找到目标结果，不需要再继续循环时，比如找列表中的某个元素，找到就停止
避免无效计算：当循环中出现不可能满足条件的情况，及时终止节省性能，比如判断质数时，一旦找到能整除的数，立刻停止试除
用户交互退出：比如写一个命令行程序，用户输入特定指令时，用 break 终止循环，退出程序

七、需要注意的地方

break 只能用在循环体（即，for 或 while 的缩进块）里，否则会报错（SyntaxError）。
在嵌套循环中，break 只影响当前所在的那一层循环，外层循环会继续执行。如果想同时终止多层循环，需要结合标志位（flag）或者其他逻辑

continue 语句

一、continue 是什么？和 break 有什么区别？

如果说 break 是循环的紧急停止按钮，那么 continue 就是循环的跳过当前按钮。它不会终止整个循环，只会跳过当前这次迭代中 continue 后面的代码，直接开始下一次循环。

简单来说：

break → 彻底不干了。
continue → 这次不干了，下次继续

二、continue 的基本语法

和 break 一样，continue 也是 Python 关键字，单独使用，写在循环体的缩进块里，通常和 if 条件配合使用。

（一）在 for 循环中用 continue

for 变量 in 序列:
    代码块1
    if 条件:
        continue  # 满足条件时，跳过当前迭代的剩余代码，直接开始下一次迭代
    代码块2  # 如果触发 continue，这部分代码不会执行
# 循环结束后执行

（二）在 while 循环中用 continue

while 条件:
    代码块1
    if 条件:
        continue  # 满足条件时，跳过当前迭代的剩余代码，直接开始下一次迭代（重新判断 while 条件）
    代码块2  # 如果触发 continue，这部分代码不会执行
    变量更新  # ⚠️ 注意：在 while 中用 continue 时，一定要确保 continue 前更新了循环条件变量，否则可能无限循环！
# 循环结束后执行

三、continue 如何工作？

以 for 循环为例：

四、实例演示：continue 在 for 和 while 中怎么用？

（一）实例1：for 循环中跳过 ‘h’

for letter in 'Python':
    if letter == 'h':
        continue  # 当字母是 'h' 时，跳过当前迭代的剩余代码（即不打印 'h'）
    print('当前字母:', letter)
print("循环结束～")

执行结果：

当前字母: P
当前字母: y
当前字母: t
当前字母: o
当前字母: n
循环结束～

解释：
for 循环遍历 ‘P’,’y’,’t’,’h’,’o’,’n’。当 letter='h' 时，continue 触发，跳过 print 语句，直接开始下一次迭代（取下一个字母 ‘o’）。所以 ‘h’ 没有被打印，但循环没有终止，后面的 ‘o’ 和 ‘n’ 正常打印。

（二）实例2：while 循环中跳过 5

var = 10
while var > 0:
    var -= 1  # ⚠️ 先减 1，再判断（避免 continue 跳过更新导致无限循环）
    if var == 5:
        continue  # 当 var=5 时，跳过后面的 print
    print('当前变量值:', var)
print("Good bye!")

执行结果：

当前变量值: 9
当前变量值: 8
当前变量值: 7
当前变量值: 6
当前变量值: 4
当前变量值: 3
当前变量值: 2
当前变量值: 1
当前变量值: 0
Good bye!

解释：

var 从 10 开始，每次循环先 var -= 1（更新变量）。
当 var=5 时，continue 触发，跳过 print 语句，直接开始下一次循环（var 继续减到 4，以此类推）。
注意：如果把 var -= 1 放在 if var ==5: continue 后面，当 var=5 时，continue 会跳过 var -=1，导致 var 永远是 5，进入无限循环！

五、continue 在嵌套循环中的表现

和 break 类似，continue 也只影响它所在的那一层循环，不会影响外层循环。

实例3：嵌套 for 循环中，continue 只跳过当前内层迭代

# 外层循环控制行（0,1,2）
for row in range(3):
    # 内层循环控制列（0,1,2,3）
    for col in range(4):
        if col == 2:
            continue  # 跳过当前列（col=2）的打印，直接开始下一列（col=3）
        print(f"({row},{col}) ", end="")
    print()  # 内层循环结束后换行

执行结果：

1
2
3

(0,0) (0,1) (0,3) 
(1,0) (1,1) (1,3) 
(2,0) (2,1) (2,3)

解释：

内层循环 col 从 0 到 3，当 col=2 时，continue 跳过当前列的 print，直接进入下一次内层循环（col=3）。
外层循环不受影响，正常执行 3 行。

六、continue 的常见使用场景

过滤不需要的元素：遍历序列时，跳过不符合条件的元素，比如说，打印列表中所有偶数，跳过奇数
跳过异常情况：处理数据时，遇到无效数据或错误格式，跳过当前处理，继续下一个

七、while 循环中使用 continue 的陷阱

在 while 循环中使用 continue 时，一定一定要保证在 continue 语句执行前，已经更新了循环条件变量！否则可能导致变量永远不满足退出条件，陷入无限循环

错误示例（无限循环）：

var = 10
while var > 0:
    if var == 5:
        continue  # 当 var=5 时，跳过下面的 var -=1
    print(var)
    var -= 1  # ❌ 这行被跳过，var 永远是 5，while 条件永远成立！

运行后会无限循环，永远停在 var=5。

正确做法，先更新变量，再判断 continue：

var = 10
while var > 0:
    var -= 1  # ✅ 先减 1，再判断
    if var == 5:
        continue
    print(var)

这样 var 会正常递减，不会无限循环

pass 语句

一、pass 是做什么的？

假如，你在写作文大纲，先把框架列好，但某些部分还没想好具体内容。pass 就像大纲里的占位符，它什么实际操作都不做，但能让代码结构保持完整，避免语法错误

简单说来说，pass 是 Python 的空语句，专门用来占位置，让代码能跑通，后续再填充逻辑

二、pass 的基本语法

pass 是 Python 关键字，单独写一行，没有参数，也不需要括号。

# 单独使用 pass
pass

# 和 if、for、while 等语句配合（作为占位）
if 条件:
    pass  # 条件满足时，什么都不做

for 变量 in 序列:
    pass  # 遍历过程中，暂时什么都不做

while 条件:
    pass  # 循环过程中，暂时什么都不做

三、为什么需要 pass？

Python 是缩进敏感的语言，代码块必须有缩进的内容，否则会报错（SyntaxError🤣）

比如，你想先写个 if 结构，但暂时没想好 if 满足时做什么：

age = 18
if age >= 18:
    # 这里还没想好写什么
# 报错：IndentationError: expected an indented block

这时候，pass 就能救场：

1
2
3

age = 18
if age >= 18:
    pass  # 先占个位置，代码结构完整，不报错

四、实例演示：pass 在不同场景的使用

（一）实例1：for 循环中用 pass 占位

for letter in 'Python':
    if letter == 'h':
        pass  # 当字母是 'h' 时，什么都不做（但结构完整）
        print('这是 pass 块')  # 可以在 pass 后写其他逻辑
    print('当前字母:', letter)
print("Good bye!")

执行结果：

当前字母: P
当前字母: y
当前字母: t
这是 pass 块
当前字母: h
当前字母: o
当前字母: n
Good bye!

解释：
当 letter='h' 时，进入 if 分支，执行 pass（啥都不做），然后执行 print('这是 pass 块') 和 print('当前字母: h')。pass 只是占位置，不影响其他代码执行。

（二）实例2：定义空函数时用 pass

如果想先定义一个函数，但还没写实现逻辑，可以用 pass 占位：

def my_function():
    pass  # 函数体不能为空，用 pass 占位

my_function()  # 调用函数，不会报错（虽然函数里啥都没做）

（三）实例3：定义空类时用 pass

同理，定义类但暂时不想写属性/方法时：

class MyClass:
    pass  # 类体不能为空，用 pass 占位

obj = MyClass()  # 实例化类，不会报错

（四）实例4：if-else 结构中用 pass 占位

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    pass  # 暂时没想好“良好”要做什么，先占位置
else:
    print("加油")

执行后，当 score=85 时，进入 elif 分支，执行 pass（摸鱼🐟），然后程序继续往下走。

五、pass 和注释有什么区别？

注释（# 开头）：是给人看的说明，Python 会直接忽略，不会占代码结构的位置。如果用注释代替 pass 放在代码块里，会因为代码块为空报错
pass：是给 Python 看的空操作，会让代码块有内容，避免语法错误，同时不影响程序执行逻辑

比如，错误示范（用注释代替 pass）：

1
2
3

if True:
    # 这里暂时没内容
# 报错：IndentationError: expected an indented block

正确示范（用 pass）：

1 2	if True: pass # 占位，不报错

六、pass 的使用场景总结

代码草稿阶段：先把结构，比如循环、分支、函数、类搭好，用 pass 占住每个代码块的位置，后续再填充逻辑
临时占位：调试代码时，想跳过某段逻辑但又不想删除代码，用 pass 暂时替代，保留结构。
满足语法要求：Python 规定代码块不能空，pass 用来充数，让语法合法。

七、pass 只占位置，不影响逻辑

pass 什么都不做，所以不会改变程序执行流程。比如在循环里用 pass，循环会正常执行迭代，只是当前迭代里 pass 所在的代码块啥都没干。

比如：

for i in range(3):
    if i == 1:
        pass  # 当 i=1 时，啥都不做
    print(i)

执行结果：

1
2
3

0
1
2

i=1 时，pass 只是占位置，print(i) 依然会执行~

学会 pass ，代码结构也不会因为暂时没内容而报错啦 🛠️ 写代码时，先搭框架，再填细节，这样效率会高很多

练习

一、基础热身：循环语法与控制流

练习1：打印1~10中的偶数（用 for 循环 + continue）

要求：遍历1到10，跳过奇数，打印所有偶数。
提示：用 range(1, 11) 生成1~10，判断 i % 2 != 0 时用 continue 跳过。

参考答案

for i in range(1, 11):
    if i % 2 != 0:  # 如果是奇数
        continue
    print(i, end=' ')  # 输出：2 4 6 8 10

练习2：计算1~100的和（用 while 循环 + break）

要求：从1开始累加，当和超过2000时停止，打印最终的和与此时的数字。
提示：用 while True 无限循环，累加后判断是否超过2000，超过则 break。

参考答案

total = 0
num = 1
while True:
    total += num
    if total > 2000:
        break
    num += 1
print(f"和为{total}，此时数字是{num}")  # 输出：和为2016，此时数字是63

练习3：用 pass 完善代码框架

要求：补全以下代码，当 score >= 60 时打印“及格”，否则用 pass 占位（不做任何事）。

score = 55
if score >= 60:
    print("及格")
else:
    # 此处用 pass 占位
    ______  # 请填空

参考答案

score = 55
if score >= 60:
    print("及格")
else:
    pass  # 占位，不执行任何操作

二、进阶实战：循环嵌套与逻辑综合

练习4：打印99乘法表（嵌套 for 循环）

要求：用嵌套循环打印经典的99乘法表，格式如下（只打印到 i*j，不超过10）：

1×1=1
2×1=2  2×2=4
3×1=3  3×2=6  3×3=9
...
9×1=9  ...  9×9=81

提示：外层循环控制行数 i（1~~9），内层循环控制列数 j（1~~i）。

参考答案

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

练习5：寻找100~200中的质数（break 优化）

要求：找出100到200之间的所有质数（只能被1和自身整除的数），并打印。
提示：

质数判断：对于 num，检查2到 sqrt(num) 之间是否有除数，有则不是质数，用 break 提前退出检查。
用 math.sqrt() 计算平方根（需 import math）。

参考答案

import math

for num in range(100, 201):
    is_prime = True  # 假设是质数
    # 检查除数从2到sqrt(num)
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            is_prime = False
            break  # 找到除数，提前退出内层循环
    if is_prime:
        print(num, end=' ')  # 输出：101 103 107 ... 199

练习6：猜数字游戏（while + break + 条件判断）

要求：程序随机生成1~100的整数，用户输入数字猜大小，直到猜对为止，统计猜的次数。
提示：

用 random.randint(1, 100) 生成随机数（需 import random）。
用 while True 循环，猜对时 break，否则提示“太大”或“太小”。

参考答案

import random

secret = random.randint(1, 100)
count = 0
print("猜数字游戏（1~100）：")

while True:
    guess = int(input("请输入你猜的数字："))
    count += 1
    if guess > secret:
        print("太大了！")
    elif guess < secret:
        print("太小了！")
    else:
        print(f"恭喜猜对了！共猜了{count}次")
        break  # 猜对后退出循环

三、综合挑战：循环与列表/字符串结合

练习7：筛选列表中的特定元素（for + continue）

要求：给定列表 numbers = [1, -2, 3, -4, 5, -6, 7, -8, 9]，筛选出所有正数并计算它们的平方和。
提示：遍历列表，遇到负数用 continue 跳过，正数则累加平方。

参考答案

numbers = [1, -2, 3, -4, 5, -6, 7, -8, 9]
sum_squares = 0

for num in numbers:
    if num <= 0:
        continue  # 跳过非正数
    sum_squares += num ** 2  # 累加平方

print(f"正数平方和：{sum_squares}")  # 输出：1+9+25+49+81=165

练习8：字符串去重与逆序（循环 + 条件判断）

要求：给定字符串 s = "abracadabra"，完成以下操作：

去重：保留首次出现的字符，删除后续重复字符（结果为 "abrcd"）。
逆序：将去重后的字符串逆序输出（结果为 "dc rba"）。
提示：

去重：用空列表记录已出现的字符，遍历字符串时判断是否在列表中，不在则添加。
逆序：用 [::-1] 或循环倒序拼接。

参考答案

s = "abracadabra"
unique_chars = []

# 1. 去重：保留首次出现的字符
for char in s:
    if char not in unique_chars:
        unique_chars.append(char)
unique_str = ''.join(unique_chars)  # 结果："abrcd"

# 2. 逆序输出
reversed_str = unique_str[::-1]  # 切片逆序，结果："dc rba"
print(f"去重后：{unique_str}，逆序后：{reversed_str}")

四、思考题：深度理解循环控制

练习9：以下代码的输出是什么？为什么？

for i in range(5):
    if i == 2:
        continue
    print(i)
    if i == 3:
        break
else:
    print("循环正常结束")

提示：for-else 结构中，else 只在循环正常结束（未被 break 终止）时执行。

答案与解析

输出：

1
2
3

0
1
3

解析：

i=0：打印0；i=1：打印1；i=2：continue 跳过打印；i=3：打印3后 break 终止循环，else 不执行。

练习10：用 while 循环实现“斐波那契数列”前10项

斐波那契数列：1, 1, 2, 3, 5, 8…（从第3项起，每项是前两项之和）。
要求：用 while 循环生成前10项并打印。

参考答案

a, b = 1, 1  # 前两项
count = 2  # 已生成2项
print(a, b, end=' ')

while count < 10:
    c = a + b
    print(c, end=' ')
    a, b = b, c  # 更新前两项
    count += 1  # 计数+1

文章作者: 码头

文章链接: https://blog.toumatou.cn/2025/10/27/Python-%E5%9F%BA%E7%A1%80%E7%AF%87/Python%20%E5%BE%AA%E7%8E%AF%E8%AF%AD%E5%8F%A5/

编程

投喂作者

支付宝

Python 循环语句

什么是循环？

循环是如何工作的？

Python 中的循环类型

1. while 循环

2. for 循环

3. 嵌套循环

循环控制语句

1. break 语句

2. continue 语句

3. pass 语句

Python While 循环语句

1.1 while 循环的基本结构

1.2 while 循环是如何工作的？

1.3 第一个 while 循环实例

2. 循环控制：break 和 continue

2.1 break 语句：立即终止循环，跳出！

2.2 continue 语句：跳过本次循环剩余部分，直接开始下一次循环

3. 无限循环：停不下来的循环

3.1 一个简单的无限循环例子

3.2 如何终止不小心写出的无限循环？

4. while ... else 语句

5. 简单语句组

For 循环语句

2.1 for 循环的基本结构

2.2 for 循环是如何工作的？

2.3 实例1：遍历字符串

2.4 实例2：遍历列表

2.5 通过序列索引进行遍历，配合 range() 和 len()

2.6 for 循环中的 break 和 continue

2.7 for ... else 语句：循环正常结束时执行的操作

2.8 更多实例：用 for 循环打印图案

嵌套循环

一、什么是循环嵌套？

二、循环嵌套的基本语法

（一）for 循环嵌套 for 循环

（二）while 循环嵌套 while 循环

（三）混合嵌套（比如 for 套 while，while 套 for）

三、循环嵌套如何执行？

四、实战：用嵌套循环找 2~100 的素数

思路：

代码实现（while 套 while）：

代码执行逻辑拆解：

五、循环嵌套的注意事项

六、拓展练习：用 for 套 for 实现素数判断

break 语句

一、break 是做什么的？

二、break 的基本语法

（一）在 for 循环中用 break

（二）在 while 循环中用 break

三、break 如何工作？

四、实例演示：break 在 for 和 while 中怎么用？

（一）实例1：for 循环中遇到 ‘h’ 就停止

（二）实例2：while 循环中变量到 5 就停止

五、break 在嵌套循环中的表现

实例3：嵌套 for 循环中，break 只终止内层循环

六、break 的常见使用场景

七、需要注意的地方

continue 语句

一、continue 是什么？和 break 有什么区别？

二、continue 的基本语法

（一）在 for 循环中用 continue

（二）在 while 循环中用 continue

三、continue 如何工作？

四、实例演示：continue 在 for 和 while 中怎么用？

（一）实例1：for 循环中跳过 ‘h’

（二）实例2：while 循环中跳过 5

五、continue 在嵌套循环中的表现

实例3：嵌套 for 循环中，continue 只跳过当前内层迭代

六、continue 的常见使用场景

七、while 循环中使用 continue 的陷阱

pass 语句

一、pass 是做什么的？

二、pass 的基本语法

三、为什么需要 pass？

四、实例演示：pass 在不同场景的使用

（一）实例1：for 循环中用 pass 占位

（二）实例2：定义空函数时用 pass

（三）实例3：定义空类时用 pass

（四）实例4：if-else 结构中用 pass 占位

1. `while` 循环

2. `for` 循环

1. `break` 语句

2. `continue` 语句

3. `pass` 语句

1.1 `while` 循环的基本结构

1.2 `while` 循环是如何工作的？

1.3 第一个 `while` 循环实例

2. 循环控制：`break` 和 `continue`

2.1 `break` 语句：立即终止循环，跳出！

2.2 `continue` 语句：跳过本次循环剩余部分，直接开始下一次循环

4. `while ... else` 语句

2.1 `for` 循环的基本结构

2.2 `for` 循环是如何工作的？

2.5 通过序列索引进行遍历，配合 `range()` 和 `len()`

2.6 `for` 循环中的 `break` 和 `continue`

2.7 `for ... else` 语句：循环正常结束时执行的操作

2.8 更多实例：用 `for` 循环打印图案

五、pass 和注释有什么区别？