小菜鸟

java菜鸟号正在起航

0%

Python 3 循环详解：for 循环、while 循环与实战技巧

发表于 分类于 阅读次数： 9 Valine： 0
本文字数： 6.3k 阅读时长 ≈ 6 分钟

Python 3 循环详解：for 循环、while 循环与实战技巧

循环是编程中用于 “重复执行一段代码” 的核心语法，Python 3 提供两种主流循环结构：for 循环（适合 “已知循环次数或遍历序列” 场景）和 while 循环（适合 “未知循环次数，依赖条件判断” 场景）。本文从 “基础语法→进阶用法→循环控制→实战案例” 四个维度，系统讲解 Python 3 循环的使用方法，帮你高效处理重复逻辑。

for 循环：遍历序列或可迭代对象

for 循环的核心是 “遍历”—— 按顺序获取可迭代对象（如列表、字符串、字典）中的每个元素，执行对应代码块，直到所有元素处理完毕。

1. 基础语法

1
2
3
4
5
6
for 变量名 in 可迭代对象:
    # 每次遍历获取一个元素，赋值给“变量名”，执行代码块
    代码语句1
    代码语句2
# 循环结束后，执行后续代码
后续代码
关键概念：
  • 可迭代对象：能被for循环遍历的对象，常见类型包括：
    • 序列：列表（list）、字符串（str）、元组（tuple）；
    • 集合：集合（set）、字典（dict，默认遍历键）；
    • 其他：range 对象（生成整数序列）、文件对象等。
  • 缩进：循环体内的代码必须缩进（推荐 4 个空格），缩进不一致会报 IndentationError。

2. 常见遍历场景

场景 1：遍历列表（list）
1
2
3
4
5
6
7
8
9
# 定义列表：存储学生姓名
students = ["张三", "李四", "王五"]

# 遍历列表，逐个获取学生姓名
for name in students:
    print(f"当前学生：{name}")

# 循环结束后执行
print("所有学生已遍历完毕")

运行结果：

1
2
3
4
当前学生：张三
当前学生：李四
当前学生：王五
所有学生已遍历完毕
场景 2：遍历字符串（str）

字符串是 “字符序列”，for 循环会逐个获取每个字符：

1
2
3
4
5
6
# 定义字符串
message = "Python"

# 遍历字符串，逐个获取字符
for char in message:
    print(f"字符：{char}")

运行结果：

1
2
3
4
5
6
字符：P
字符：y
字符：t
字符：h
字符：o
字符：n
场景 3：遍历字典（dict）

字典默认遍历 “键（key）”，若需遍历 “值（value）” 或 “键值对（key-value）”，需使用 values() 或 items() 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 定义字典：存储学生成绩
scores = {"张三": 95, "李四": 88, "王五": 92}

# 1. 遍历键（默认）
print("=== 遍历键 ===")
for name in scores:
    print(f"学生：{name}")

# 2. 遍历值（用 values() 方法）
print("\n=== 遍历值 ===")
for score in scores.values():
    print(f"成绩：{score}")

# 3. 遍历键值对（用 items() 方法，返回元组 (key, value)）
print("\n=== 遍历键值对 ===")
for name, score in scores.items():
    print(f"学生：{name}，成绩：{score}")

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
=== 遍历键 ===
学生：张三
学生：李四
学生：王五

=== 遍历值 ===
成绩：95
成绩：88
成绩：92

=== 遍历键值对 ===
学生：张三，成绩：95
学生：李四，成绩：88
学生：王五，成绩：92
场景 4：遍历 range 对象（生成整数序列）

range() 是 Python 内置函数，用于生成 “不可变的整数序列”，常配合 for 循环实现 “固定次数的循环”。其语法：

  • range(stop)：生成 0 ~ stop-1 的整数（如 range(3) → 0,1,2）；
  • range(start, stop)：生成 start ~ stop-1 的整数（如 range(1,4) → 1,2,3）；
  • range(start, stop, step)：生成 start ~ stop-1 的整数，步长为 step（如 range(1,6,2) → 1,3,5）。

示例：循环 5 次，打印计数：

1
2
3
# 生成 1~5 的整数序列（range(1,6)）
for i in range(1, 6):
    print(f"第 {i} 次循环")

运行结果：

1
2
3
4
5
第 1 次循环
第 2 次循环
第 3 次循环
第 4 次循环
第 5 次循环

while 循环：基于条件的重复执行

while 循环的核心是 “条件判断”—— 只要条件表达式结果为 True，就重复执行代码块；当条件变为 False 时，循环终止。适合 “未知循环次数，需通过条件控制” 的场景（如 “直到用户输入正确密码才停止循环”）。

1. 基础语法

1
2
3
4
5
6
7
8
9
10
11
# 1. 初始化条件变量（可选，若条件依赖变量）
条件变量 = 初始值

while 条件表达式:
    # 条件为 True 时执行代码块
    代码语句1
    代码语句2
    # 2. 更新条件变量（关键！避免无限循环）
    条件变量 = 新值
# 循环结束后执行后续代码
后续代码
关键注意：
  • 避免无限循环：必须在循环体内更新 “条件变量”（如 i += 1），否则条件会一直为 True，导致循环永不终止（需按 Ctrl+C 强制停止）；
  • 条件表达式：结果必须是布尔值（True/False），非布尔值会自动转换（如 0→False，非 0 数字→True）。

2. 常见使用场景

场景 1：固定次数循环（模拟 for 循环）
1
2
3
4
5
6
7
8
9
10
# 初始化计数器：从 1 开始
count = 1

# 条件：计数器 <= 5（循环 5 次）
while count <= 5:
    print(f"第 {count} 次循环")
    # 更新计数器：每次 +1（关键！）
    count += 1

print("循环结束")

运行结果：

1
2
3
4
5
6
第 1 次循环
第 2 次循环
第 3 次循环
第 4 次循环
第 5 次循环
循环结束
场景 2：直到用户输入正确才停止
1
2
3
4
5
6
7
8
9
10
11
12
13
# 预设正确密码
correct_password = "python123"

# 初始化用户输入（空字符串，确保首次循环条件为 True）
user_input = ""

# 条件：用户输入 != 正确密码（输入错误则继续循环）
while user_input != correct_password:
    user_input = input("请输入密码：")
    if user_input != correct_password:
        print("密码错误，请重新输入！")

print("密码正确，登录成功！")

运行结果：

1
2
3
4
请输入密码：123456
密码错误，请重新输入！
请输入密码：python123
密码正确，登录成功！
场景 3：处理未知长度的数据（如读取文件）
1
2
3
4
5
6
7
8
9
10
11
12
# 模拟从文件读取数据（每次读取一行，直到无数据）
# 实际场景中可替换为 open("file.txt", "r") 读取文件
lines = ["第一行数据", "第二行数据", "第三行数据"]
index = 0

# 条件：索引 < 列表长度（未读完所有行）
while index < len(lines):
    print(f"读取到：{lines[index]}")
    # 更新索引：每次 +1
    index += 1

print("所有数据已读取完毕")

运行结果：

1
2
3
4
读取到：第一行数据
读取到：第二行数据
读取到：第三行数据
所有数据已读取完毕

循环控制：break、continue、else

Python 提供 break、continue 关键字控制循环流程，以及 else 子句处理 “循环正常结束” 的场景，灵活应对复杂逻辑。

1. break：终止整个循环

break 用于 “立即终止当前循环”，无论循环条件是否满足，直接跳出循环，执行循环后的代码。

示例：遍历列表，找到目标元素后终止循环：

1
2
3
4
5
6
7
8
9
10
11
12
# 定义列表：存储数字
numbers = [10, 20, 30, 40, 50]
target = 30  # 目标元素

# 遍历列表，查找目标元素
for num in numbers:
    if num == target:
        print(f"找到目标元素：{num}，终止循环")
        break  # 找到后立即终止循环
    print(f"当前元素：{num}（不是目标）")

print("循环结束")

运行结果：

1
2
3
4
当前元素：10（不是目标）
当前元素：20（不是目标）
找到目标元素：30，终止循环
循环结束

2. continue：跳过当前迭代，进入下一次

continue 用于 “跳过当前迭代的剩余代码”，直接进入下一次循环（不会终止整个循环）。

示例：遍历 1~5，跳过偶数，打印奇数：

1
2
3
4
5
# 遍历 1~5
for i in range(1, 6):
    if i % 2 == 0:  # 判断是否为偶数
        continue  # 跳过偶数的后续代码，进入下一次循环
    print(f"奇数：{i}")

运行结果：

1
2
3
奇数：1
奇数：3
奇数：5

3. else 子句：循环正常结束时执行

for/while 循环可搭配 else 子句，仅当循环 “正常结束”（未被 break 终止）时，才执行 else 中的代码。

场景：判断列表中是否存在目标元素
1
2
3
4
5
6
7
8
9
10
11
12
# 定义列表
fruits = ["苹果", "香蕉", "橙子"]
target = "葡萄"

# 遍历列表查找目标
for fruit in fruits:
    if fruit == target:
        print(f"找到目标水果：{target}")
        break
else:
    # 仅当循环未被 break 终止时执行（即未找到目标）
    print(f"未找到目标水果：{target}")

运行结果：

1
未找到目标水果：葡萄

嵌套循环：循环内部嵌套循环

当需要 “在一个循环中执行另一个循环” 时（如 “遍历矩阵的每行每列”“打印九九乘法表”），使用嵌套循环—— 外层循环控制 “大的重复单元”，内层循环控制 “小的重复单元”。

1. 基础语法（以 for 嵌套 for 为例）

1
2
3
4
5
6
for 外层变量 in 外层可迭代对象:
    # 外层循环代码
    print(f"外层循环：{外层变量}")
    for 内层变量 in 内层可迭代对象:
        # 内层循环代码（外层循环的每次迭代，内层循环执行完整一轮）
        print(f"  内层循环：{内层变量}")
关键注意：
  • 内层循环的缩进比外层多 4 个空格，确保层级清晰；
  • 外层循环执行 1 次，内层循环执行 “完整的所有次”（如外层循环 3 次，内层循环 2 次，总执行次数为 3×2=6 次）。

2. 实战示例：打印九九乘法表

1
2
3
4
5
6
7
8
# 外层循环：控制行数（1~9）
for i in range(1, 10):
    # 内层循环：控制每行的列数（1~当前行数 i）
    for j in range(1, i+1):
        # 打印乘法表达式（不换行，用 end="\t" 分隔）
        print(f"{j}×{i}={i*j}", end="\t")
    # 每行结束后换行
    print()

运行结果：

1
2
3
4
5
6
7
8
9
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    6×6=36    
1×7=7    2×7=14    3×7=21    4×7=28    5×7=35    6×7=42    7×7=49    
1×8=8    2×8=16    3×8=24    4×8=32    5×8=40    6×8=48    7×8=56    8×8=64    
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. 优先使用内置函数 / 推导式（替代手动循环）

Python 内置函数（如 map()、filter()）和推导式（列表推导式、字典推导式）是用 C 语言实现的，效率远高于手动 for 循环。

示例：生成 1~10 的平方列表

  • 低效：手动for循环

    1
    2
    3
    4
    squares = []
    for i in range(1, 11):
        squares.append(i ** 2)
    print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

  • 高效：列表推导式

    1
    2
    squares = [i ** 2 for i in range(1, 11)]
    print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2. 减少循环内部的计算量

将循环外不变的计算（如函数调用、常量定义）移到循环外，避免重复计算：

1
2
3
4
5
6
7
8
9
10
11
12
import math

# 低效：循环内重复调用 math.sqrt(100)（结果不变）
for i in range(1000000):
    if i < math.sqrt(100):
        pass

# 高效：循环外计算一次，复用结果
sqrt_100 = math.sqrt(100)
for i in range(1000000):
    if i < sqrt_100:
        pass

3. 避免在循环中修改可迭代对象

遍历列表时，若直接修改列表（如 append()、remove()），会导致索引混乱，引发错误或逻辑异常。如需修改，建议遍历列表的副本：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 错误示例：遍历中删除元素，导致漏删
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # 会导致 4 被漏删
print(numbers)  # [1, 3, 5]？实际结果是 [1, 3, 5]（本例巧合正确，复杂场景会出错）

# 正确示例：遍历列表副本（用 numbers[:] 创建副本）
numbers = [1, 2, 3, 4, 5]
for num in numbers[:]:  # 遍历副本，不影响原列表
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # [1, 3, 5]（正确）

for 循环 vs while 循环：如何选择？

对比维度 for 循环 while 循环
核心场景 已知循环次数、遍历可迭代对象（列表、字符串等） 未知循环次数、依赖条件判断（如 “直到输入正确”）
循环控制 自动遍历，无需手动控制索引 需手动初始化 / 更新条件变量（避免无限循环
相关文章

欢迎关注我的其它发布渠道

表情 | 预览
快来做第一个评论的人吧~
Powered By Valine
v1.3.10