while 循环

当条件为 True 时，重复执行一段代码块，直到条件变为 False 为止

while 循环是 Python 中最基础的循环结构，适用于不确定循环次数的场景。

  1. while 循环的基本格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""
while 条件:
    条件成立时重复执行的代码
注意：只要条件为 True，循环内的代码就会一直执行
"""
# 输出 1 到 5
i = 1
while i <= 5:
    print(i)
    i += 1  # 每次循环 i 自增1，否则会陷入死循环

# 输出：
# 1
# 2
# 3
# 4
# 5
  1. while 循环的执行流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
1. 判断条件是否为 True
2. 如果为 True，执行循环体中的代码
3. 执行完毕后，再次判断条件
4. 如果仍为 True，继续执行循环体
5. 直到条件变为 False，退出循环
"""
# 计算 1 到 100 的累加和
i = 1
total = 0
while i <= 100:
    total += i
    i += 1
print(f"1到100的累加和为：{total}")  # 输出 1到100的累加和为：5050
  1. 死循环与注意事项
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
死循环：条件永远为 True，循环无法终止
如果不小心写了死循环，按 Ctrl+C 强制终止程序
"""
# 以下为死循环示例（不要运行）
# while True:
#     print("无限循环...")

# 正确的写法：必须有让条件变为 False 的出口
count = 0
while count < 3:
    print(f"第 {count + 1} 次循环")
    count += 1  # 必须有这行，否则就是死循环

# 输出：
# 第 1 次循环
# 第 2 次循环
# 第 3 次循环
  1. while 循环的实际应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 猜数字游戏（有次数限制）
import random
target = random.randint(1, 100)
guess = 0       # 初始化猜测值
attempts = 0    # 记录猜测次数

while guess != target:
    guess = int(input("猜一个1~100之间的数字："))
    attempts += 1
    if guess > target:
        print("猜大了，再试试")
    elif guess < target:
        print("猜小了，再试试")

print(f"恭喜猜对了！共猜了 {attempts} 次")
1
2
3
4
5
6
7
# 用户输入求和（输入0结束）
total = 0
num = int(input("请输入数字（输入0结束）："))
while num != 0:
    total += num
    num = int(input("请输入数字（输入0结束）："))
print(f"所有输入数字的总和为：{total}")

for 循环

用于遍历序列（列表、元组、字符串、range等）中的每一个元素

for 循环是 Python 中最常用的循环结构，特别适合已知循环次数或需要遍历容器的场景。

  1. for 循环的基本格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
for 变量 in 可迭代对象:
    对每个元素执行的代码
"""
# 遍历字符串中的每个字符
for char in "Python":
    print(char)

# 输出：
# P
# y
# t
# h
# o
# n
  1. range() 函数

生成一个整数序列，常与 for 循环配合使用

range() 是 for 循环的最佳搭档，用于控制循环的次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
"""
range() 的三种用法：
range(stop)          从0开始，到stop结束（不包含stop）
range(start, stop)   从start开始，到stop结束（不包含stop）
range(start, stop, step)  从start开始，步长为step
"""
# range(stop)
for i in range(5):
    print(i, end=" ")  # 输出：0 1 2 3 4
print()

# range(start, stop)
for i in range(2, 6):
    print(i, end=" ")  # 输出：2 3 4 5
print()

# range(start, stop, step)
for i in range(1, 10, 2):
    print(i, end=" ")  # 输出：1 3 5 7 9
print()

# step 可以为负数（倒序）
for i in range(5, 0, -1):
    print(i, end=" ")  # 输出：5 4 3 2 1
print()
  1. for 循环遍历常见数据类型 （重点）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 遍历列表
fruits = ["苹果", "香蕉", "橘子", "葡萄"]
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

# 输出：
# 我喜欢吃苹果
# 我喜欢吃香蕉
# 我喜欢吃橘子
# 我喜欢吃葡萄

# 遍历元组
colors = ("红", "绿", "蓝")
for color in colors:
    print(color)  # 依次输出 红 绿 蓝

# 遍历字典
student = {"name": "小明", "age": 18, "score": 95}
for key in student:             # 遍历键
    print(f"{key}: {student[key]}")
# 输出：
# name: 小明
# age: 18
# score: 95

for key, value in student.items():  # 同时遍历键和值
    print(f"{key} = {value}")
# 输出：
# name = 小明
# age = 18
# score = 95
  1. for 循环的经典应用
1
2
3
4
5
6
7
8
9
10
11
# 计算 1 到 100 的累加和
total = 0
for i in range(1, 101):
    total += i
print(f"1到100的累加和为：{total}")  # 输出 5050

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

for 循环正常结束后执行 else 代码块；如果被 break 中断，则不执行 else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
"""
for 变量 in 可迭代对象:
    循环体
else:
    循环正常结束后执行的代码（没有被break中断时）
"""
# 正常结束：执行 else
for i in range(3):
    print(i)
else:
    print("循环正常结束")

# 输出：
# 0
# 1
# 2
# 循环正常结束

# 被 break 中断：不执行 else
for i in range(5):
    if i == 3:
        print("遇到3，中断循环")
        break
    print(i)
else:
    print("这句不会被执行")

# 输出：
# 0
# 1
# 2
# 遇到3，中断循环

循环中断控制

在循环执行过程中，通过 break 和 continue 控制循环的流程

Python 提供了两个关键字来控制循环的执行流程：break（跳出循环）和 continue（跳过本次）。

  1. break 语句

立即终止当前循环，跳出循环体，执行循环后面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# break：找到目标后立即停止循环
nums = [3, 7, 2, 9, 5, 8]
target = 9
for num in nums:
    print(f"正在检查：{num}")
    if num == target:
        print(f"找到了 {target}！")
        break  # 找到后立即结束循环，不再检查后续元素

# 输出：
# 正在检查：3
# 正在检查：7
# 正在检查：2
# 正在检查：9
# 找到了 9！
1
2
3
4
5
6
7
8
# break 在 while 循环中的应用
# 反复输入，直到输入 quit 为止
while True:
    command = input("请输入命令（输入 quit 退出）：")
    if command == "quit":
        print("程序结束")
        break
    print(f"执行命令：{command}")
  1. continue 语句

跳过当前循环的剩余代码，直接进入下一次循环的判断

1
2
3
4
5
6
7
# continue：跳过偶数，只打印奇数
for i in range(1, 11):
    if i % 2 == 0:
        continue  # 如果是偶数，跳过本次循环剩余代码
    print(i, end=" ")

# 输出：1 3 5 7 9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# continue 的实际应用：过滤无效数据
scores = [85, -1, 92, 105, 78, -5, 88]
valid_scores = []
for score in scores:
    if score < 0 or score > 100:  # 跳过无效分数
        print(f"无效分数：{score}，已跳过")
        continue
    valid_scores.append(score)

print(f"有效分数：{valid_scores}")
# 输出：
# 无效分数：-1，已跳过
# 无效分数：105，已跳过
# 无效分数：-5，已跳过
# 有效分数：[85, 92, 78, 88]
  1. break 与 continue 的区别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
"""
break：直接终止整个循环，不再执行任何循环代码
continue：只跳过本轮循环剩余代码，继续执行下一轮

类比：
break  → 今天的工作全部结束，直接下班回家
continue → 当前任务不做，跳过，继续做下一个任务
"""
# 对比演示
print("=== break 演示 ===")
for i in range(1, 6):
    if i == 3:
        break       # 遇到3，循环结束
    print(i, end=" ")
# 输出：1 2

print("\n=== continue 演示 ===")
for i in range(1, 6):
    if i == 3:
        continue    # 遇到3，跳过，继续4和5
    print(i, end=" ")
# 输出：1 2 4 5

循环嵌套

在一个循环体内部再包含另一个循环，常用于处理多维数据或组合场景

循环嵌套（多重循环）可以实现更复杂的遍历和计算逻辑。外层循环执行一次，内层循环要完整执行一遍。

  1. 基本嵌套格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
for 外层变量 in 外层序列:
    for 内层变量 in 内层序列:
        内层循环体（执行次数 = 外层次数 × 内层次数）
"""
# 打印坐标网格
for x in range(1, 4):       # 外层循环：3次
    for y in range(1, 3):   # 内层循环：2次
        print(f"({x}, {y})", end=" ")
    print()  # 换行

# 输出（共执行 3×2=6 次内层循环体）：
# (1, 1) (1, 2)
# (2, 1) (2, 2)
# (3, 1) (3, 2)
  1. 九九乘法表
1
2
3
4
5
6
7
8
9
10
11
12
# 经典九九乘法表（双重for循环嵌套）
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i * j:2d}", end="  ")
    print()

# 输出：
# 1×1= 1
# 1×2= 2  2×2= 4
# 1×3= 3  2×3= 6  3×3= 9
# ...
# 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
  1. while 嵌套与 for 嵌套混用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 打印三角形图案
"""
*
**
***
****
*****
"""
row = 1
while row <= 5:              # 外层：控制行数
    for col in range(row):   # 内层：控制每行星号数量
        print("*", end="")
    print()                  # 换行
    row += 1
  1. 循环嵌套中的 break 与 continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
在嵌套循环中，break 和 continue 只作用于当前所在的那一层循环
"""
# break 只跳出内层循环
for i in range(1, 4):
    for j in range(1, 4):
        if j == 2:
            break  # 只跳出内层循环
        print(f"({i}, {j})", end=" ")
    print()

# 输出（内层每次遇到j==2就停止，但外层继续）：
# (1, 1)
# (2, 1)
# (3, 1)
1
2
3
4
5
6
7
8
9
10
11
# 跳出外层循环的技巧：使用标志变量
found = False
for i in range(1, 6):
    for j in range(1, 6):
        if i * j == 20:
            print(f"找到了：{i} × {j} = 20")
            found = True
            break   # 跳出内层
    if found:
        break   # 跳出外层
# 输出：找到了：4 × 5 = 20

循环遍历进阶 （了解即可）

掌握更多循环技巧，让代码更简洁高效

  1. enumerate() — 同时获取索引和值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# enumerate() 返回 (索引, 元素) 的元组
fruits = ["苹果", "香蕉", "橘子"]
for _ in enumerate(fruits):
    print(_)
# 输出：
# (0, '苹果')
# (1, '香蕉')
# (2, '橘子')

for index, fruit in enumerate(fruits):
    print(f"第 {index + 1} 个水果是：{fruit}")
# 输出：
# 第 1 个水果是：苹果
# 第 2 个水果是：香蕉
# 第 3 个水果是：橘子

# 可指定起始索引
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")  # 索引从1开始
# 输出
# 1. 苹果
# 2. 香蕉
# 3. 橘子
  1. zip() — 同时遍历多个序列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# zip() 将多个序列的元素一一配对
names = ["小明", "小红", "小刚"]
scores = [95, 88, 76]
for name, score in zip(names, scores):
    print(f"{name} 的成绩是 {score}")

# 输出：
# 小明 的成绩是 95
# 小红 的成绩是 88
# 小刚 的成绩是 76

# 如果序列长度不同，以最短的为准
a = [1, 2, 3, 4]
b = ["a", "b", "c"]
for x, y in zip(a, b):
    print(x, y)  # 只输出前3对
  1. 列表推导式（简洁写法）重点
1
2
3
4
5
6
7
8
9
10
11
12
13
# 普通 for 循环：生成 1~10 的平方列表
squares = []
for i in range(1, 11):
    squares.append(i ** 2)
print(squares)  # 输出 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 使用列表推导式（一行搞定）
squares = [i ** 2 for i in range(1, 11)]
print(squares)  # 输出 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 带条件的列表推导式
even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_squares)  # 输出 [4, 16, 36, 64, 100]

综合练习

将所学知识融会贯通，通过实际案例巩固循环语句的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 判断素数
"""
素数（质数）：只能被1和自身整除的数，且大于1
"""
num = int(input("请输入一个大于1的整数："))
is_prime = True

if num <= 1:
    print(f"{num} 不是素数")
else:
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(f"{num} 是素数")
    else:
        print(f"{num} 不是素数")
1
2
3
4
5
6
7
8
9
10
11
# 找出 100 以内的所有素数
print("100以内的素数有：")
for num in range(2, 101):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(num, end=" ")
# 输出：2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 银行ATM取款模拟
"""
模拟简单的ATM取款流程
有3次密码输入机会，密码正确后可以反复取款
"""
correct_pin = "1234"
balance = 5000  # 初始余额

# 密码验证（最多3次机会）
for attempt in range(1, 4):
    pin = input(f"请输入密码（第{attempt}次，共3次机会）：")
    if pin == correct_pin:
        print("密码正确，登录成功！")
        break
    else:
        remaining = 3 - attempt
        if remaining > 0:
            print(f"密码错误，还剩 {remaining} 次机会")
else:
    print("密码错误次数过多，账户已锁定！")
    exit()  # 结束程序

# 取款循环
while True:
    print(f"\n当前余额：{balance} 元")
    amount = input("请输入取款金额（输入0退出）：")
    
    if amount == "0":
        print("感谢使用，再见！")
        break
    
    if not amount.isdigit():
        print("输入无效，请输入整数金额")
        continue
    
    amount = int(amount)
    if amount > balance:
        print(f"余额不足！当前余额 {balance} 元")
    elif amount <= 0:
        print("取款金额必须大于0")
    else:
        balance -= amount
        print(f"取款成功！已取 {amount} 元，剩余 {balance} 元")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 打印菱形图案
"""
输入一个奇数n，打印n行的菱形
例如 n=5：
  *
 ***
*****
 ***
  *
"""
n = int(input("请输入一个奇数："))
if n % 2 == 0:
    print("请输入奇数！")
else:
    mid = n // 2 + 1  # 中间行号
    for i in range(1, n + 1):
        spaces = abs(mid - i)          # 空格数
        stars = n - 2 * spaces         # 星号数
        print(" " * spaces + "*" * stars)

循环语句是编程中最强大的工具之一。while 适合不确定次数的场景，for 适合遍历和已知次数的场景。掌握 break/continue 和循环嵌套，配合 range()、enumerate()、zip() 等函数，能让你轻松应对各种数据处理需求。

Python Study Note 系列文章

  1. Python Study Note
  2. Python 函数使用（四）
  3. Python 判断语句（二）
  4. Python 基础语法（一）
  5. Python 异常处理（七）
  6. Python 循环语句（三）
  7. Python 数据容器（五）
  8. Python 文件基础操作（六）
  9. Python 模块与包（八）
  10. Python 类型注解（十）
  11. Python 面向对象（九）重点
  12. Python 高阶技巧（十一）