欢迎访问Python教学中心|专注高质量编程教育 · www.xservx.com

Python循环语句教学视频

Python循环语句教学视频|从入门到精通完整教程

掌握for与while循环核心语法、嵌套逻辑、break/continue控制、range函数及列表推导式技巧,结合真实案例解析与常见陷阱规避策略,助你高效构建可维护循环结构,全面提升编程能力。

开始学习

循环语句基础概览

循环是编程语言中实现重复执行的关键结构。在Python中,循环分为for循环与while循环两大类,二者在适用场景、执行逻辑与性能表现上各有特点,需结合具体任务合理选择。

〈一〉循环语句的核心价值

循环结构让程序具备处理重复性任务的能力,是构建算法、处理集合数据、实现自动化逻辑的基石。没有循环,程序只能顺序执行固定步骤,无法应对动态输入与复杂业务逻辑。

  • ⚡ 数据遍历:处理列表、元组、字典、集合等可迭代对象
  • ⚙️ 状态迭代:重复执行直到满足终止条件(如游戏主循环、服务监听)
  • 〔〕复杂计算:数值积分、模拟退火、蒙特卡洛方法等
  • 〈〉资源管理:批量创建/修改/删除文件或数据库记录

例如,若需计算1到1000000的平方和,手动写出100万次加法不现实,而循环只需几行代码即可高效完成:

计算1~1000000的平方和(使用range与for)
total = 0
for i in range(1, 1000001):
    total += i * i
print(total)  # 输出:333333833333500000

此例中,range生成高效迭代器,for循环自动解包并累加,体现了Python简洁性与表达力的统一。

〔二〕循环设计的三大黄金法则

  1. ⑴ 明确终止条件:避免死循环。for循环由可迭代对象长度决定,while需显式维护条件变量
  2. ⑵ 状态可收敛:每次迭代应使问题规模缩小或状态趋近终止
  3. ⑶ 副作用可控:循环体不应产生不可预期的全局状态变更(如修改共享变量未加锁)

反例:以下代码因未更新计数器导致死循环,程序卡死:

错误示例:漏更新计数器
i = 0
while i < 5:
    print(i)
    # 缺少 i += 1

正确写法应为:

修正后:正确更新计数器
i = 0
while i < 5:
    print(i)
    i += 1  # 关键修正

for循环:遍历的艺术

Python的for循环本质是迭代器协议的封装,不依赖索引即可安全遍历任意可迭代对象,语法简洁且语义清晰,是Python区别于C/Java等语言的标志性特性。

〈一〉for循环基本语法与执行流程

标准语法结构
for 目标变量 in 可迭代对象:
    循环体代码
[else:
    else子句(循环正常结束时执行)]

执行流程:

  1. 从可迭代对象获取迭代器
  2. 循环调用next()获取下一个元素
  3. 赋值给目标变量并执行循环体
  4. 元素耗尽时退出循环;若存在else子句则执行

示例:遍历字符串并统计元音字母数量

统计字符串中元音字母个数
vowels = 'aeiouAEIOU'
text = "Hello, Python!"
count = 0
for char in text:
    if char in vowels:
        count += 1
print(f"元音字母数量:{count}")  # 输出:元音字母数量:4

〔二〕for循环的典型应用场景

① 遍历列表与元组
② 遍历字典
③ 遍历文件行

① 遍历列表与元组

列表与元组是最常见的可迭代对象,for循环可直接遍历其元素,无需索引操作。

遍历用户评分列表并分类
scores = [95, 78, 88, 62, 91]
for score in scores:
    if score >= 90:
        level = "优秀"
    elif score >= 80:
        level = "良好"
    elif score >= 60:
        level = "及格"
    else:
        level = "不及格"
    print(f"分数{score} → 等级:{level}")

输出结果:

分数95 → 等级:优秀

分数78 → 等级:良好

分数88 → 等级:良好

分数62 → 等级:及格

分数91 → 等级:优秀

② 遍历字典

字典遍历有三种方式:键遍历、值遍历、键值对遍历,需根据需求选择。

遍历学生信息字典
students = {
    "张三": 20,
    "李四": 21,
    "王五": 19
}
# 遍历键(学生姓名)
for name in students:
    print(f"学生:{name}")
# 遍历值(年龄)
for age in students.values():
    print(f"年龄:{age}")
# 遍历键值对
for name, age in students.items():
    print(f"{name} 今年{age}岁")

③ 遍历文件行

文件对象是可迭代的,for循环可逐行读取,避免一次性加载大文件导致内存溢出。

逐行处理日志文件
with open("app.log", "r", encoding="utf-8") as f:
    for line_num, line in enumerate(f, start=1):
        if "ERROR" in line:
            print(f"[第{line_num}行] 错误日志:{line.strip()}")

⚡ for循环的增强特性

1. enumerate():带索引的遍历

使用enumerate获取索引与值
colors = ["红", "绿", "蓝"]
for idx, color in enumerate(colors):
    print(f"第{idx+1}种颜色:{color}")

2. zip():并行遍历多个序列

并行遍历姓名与分数
names = ["张三", "李四", "王五"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name} 得分:{score}")

3. reversed():反向遍历

反向输出列表元素
numbers = [1, 2, 3, 4, 5]
for num in reversed(numbers):
    print(num, end=" ")  # 输出:5 4 3 2 1

while循环:条件驱动的迭代

当循环次数未知、依赖动态条件时,while循环是唯一选择。其核心在于维护循环变量的收敛性,确保条件最终为假。

〈一〉while循环基本结构

标准语法
while 条件表达式:
    循环体代码
[else:
    else子句(条件为假时执行)]

关键要点:

  • ⑴ 条件表达式为真时持续执行
  • ⑵ 循环体内必须更新条件相关变量
  • ⑶ else子句仅在循环条件首次为假或正常结束时执行(break不触发)

示例:模拟用户登录尝试(最多3次)

模拟登录验证流程
correct_pwd = "Python2024"
attempts = 0
max_attempts = 3
while attempts < max_attempts:
    pwd = input("请输入密码:")
    if pwd == correct_pwd:
        print("登录成功!")
        break
    else:
        attempts += 1
        print(f"密码错误,剩余尝试次数:{max_attempts - attempts}")
else:
    print("账户已锁定,请联系管理员。")

〔二〕while循环的典型场景

① 输入验证循环
② 服务监听循环
③ 数值迭代循环

① 输入验证循环

确保用户输入符合预期格式,避免程序因非法输入崩溃。

持续要求输入有效整数
while True:
    try:
        age = int(input("请输入年龄:"))
        if age < 0 or age > 150:
            print("年龄范围无效,请输入0~150之间的整数")
            continue
        print(f"您的年龄是:{age}")
        break
    except ValueError:
        print("输入格式错误,请输入整数")

② 服务监听循环

服务器程序常使用while循环持续监听端口,处理客户端请求。

简易TCP服务器主循环
import socket
server = socket.socket()
server.bind(("0.0.0.0", 8080))
server.listen(5)
print("服务器启动,等待连接...")
while True:
    client, addr = server.accept()
    print(f"连接来自:{addr}")
    data = client.recv(1024)
    client.send(f"收到:{data.decode()}".encode())
    client.close()

③ 数值迭代循环

当需要精确控制步长或非线性增长时,while比for更灵活。

计算斐波那契数列小于1000的项
a, b = 0, 1
while a < 1000:
    print(a, end=" ")
    a, b = b, a + b

⚠️ while循环常见陷阱与规避

陷阱1:忘记更新循环变量

现象:程序卡死,CPU占用率100%

解决方案:始终在循环体内更新条件相关变量,并添加超时保护

陷阱2:条件表达式逻辑错误

示例:使用and代替or导致条件永不满足

正确写法:检查逻辑运算符是否符合业务需求

陷阱3:浮点数精度问题

示例:while x != 1.0可能永远不退出

解决方案:使用abs(x - 1.0) < 1e-9比较浮点数

break与continue:循环控制的艺术

Python提供break和continue两个关键字,用于精确控制循环流程,避免冗余条件判断,提升代码可读性。

〈一〉break:终止当前循环

立即跳出最近一层循环,执行循环外代码(若存在else则跳过)。

查找第一个能被7整除的三位数
for num in range(100, 1000):
    if num % 7 == 0:
        print(f"第一个能被7整除的三位数是:{num}")
        break

输出结果:第一个能被7整除的三位数是:105

注意:嵌套循环中,break仅终止最内层循环

〔二〕continue:跳过本次迭代

立即结束当前循环体剩余代码,进入下一次迭代。

跳过偶数,只输出1~20的奇数
for i in range(1, 21):
    if i % 2 == 0:
        continue
    print(i, end=" ")

输出结果:1 3 5 7 9 11 13 15 17 19

〔三〕break/continue与else子句

循环的else子句仅在循环正常结束(未被break中断)时执行,这是重要设计特性。

检查列表中是否存在负数
numbers = [10, 20, -5, 30]
for num in numbers:
    if num < 0:
        print(f"发现负数:{num}")
        break
else:
    print("所有数字均为非负数")

执行结果:发现负数:-5(break触发,else不执行)

💡 设计哲学

else子句本质是"未触发break时的默认行为",适用于查找、验证等场景,避免额外标志变量,体现Python"优雅即简洁"的设计哲学。

range函数:高效迭代器的基石

Python的range函数是生成器的早期实现,提供内存友好的整数序列生成机制,是for循环高效执行的关键支撑。

〈一〉range语法与参数说明

函数签名
range(stop)
range(start, stop[, step])
参数 类型 说明 默认值
start 整数 序列起始值(包含) 0
stop 整数 序列终止值(不包含) 无默认
step 整数 步长(可为负数) 1

重要特性:

  • ⑴ 生成惰性迭代器(不占用大量内存)
  • ⑵ 仅支持整数,浮点数需用numpy.arange
  • ⑶ step为0时抛出ValueError异常

〔二〕range典型应用案例

① 生成正向序列
② 生成反向序列
③ 生成等差数列

① 生成正向序列

遍历0~4的整数
for i in range(5):
    print(i, end=" ")  # 输出:0 1 2 3 4

② 生成反向序列

倒序输出5~1
for i in range(5, 0, -1):
    print(i, end=" ")  # 输出:5 4 3 2 1

③ 生成等差数列

生成1~10的奇数序列
for i in range(1, 11, 2):
    print(i, end=" ")  # 输出:1 3 5 7 9

⚡ range性能优势实测

对比列表生成与range在内存占用上的差异:

内存占用对比(生成100万个整数)
import sys
# 列表生成
lst = [i for i in range(1000000)]
print(f"列表内存:{sys.getsizeof(lst)} 字节")  # 约8MB
# range迭代器
rng = range(1000000)
print(f"range内存:{sys.getsizeof(rng)} 字节")  # 48字节

结论:range作为迭代器,内存占用恒定(约48字节),而列表随元素数量线性增长,大规模数据处理时必须优先使用range。

嵌套循环:多维数据处理的核心

嵌套循环是处理矩阵、二维列表、树形结构等多维数据的基础工具,但需警惕时间复杂度指数级增长的风险。

〈一〉嵌套循环基本结构

标准结构
for 外层变量 in 外层序列:
    for 内层变量 in 内层序列:
        内层循环体
    外层循环体剩余代码

执行逻辑:外层循环每执行1次,内层循环完整执行一圈

〔二〕嵌套循环典型应用

① 打印乘法表
② 遍历二维列表
③ 矩阵转置

① 打印九九乘法表

标准九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j:<2}", end="\t")
    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

② 遍历二维列表

处理学生成绩表(每行一个学生,每列一科成绩)

计算每个学生的平均分
scores = [
    [85, 92, 78],
    [90, 88, 95],
    [76, 85, 91]
]
for i, student_scores in enumerate(scores):
    avg = sum(student_scores) / len(student_scores)
    print(f"学生{i+1}平均分:{avg:.2f}")

③ 矩阵转置

将3×2矩阵转为2×3矩阵

使用嵌套循环转置矩阵
matrix = [
    [1, 2],
    [3, 4],
    [5, 6]
]
# 创建转置矩阵
transposed = []
for i in range(len(matrix[0])):
    row = []
    for j in range(len(matrix)):
        row.append(matrix[j][i])
    transposed.append(row)
print(transposed)  # 输出:[[1, 3, 5], [2, 4, 6]]

⚠️ 嵌套循环性能陷阱

时间复杂度爆炸

问题:三重嵌套循环处理1000×1000×1000数据需10^9次操作

解决方案:使用numpy向量化操作或算法优化(如分治、剪枝)

内层循环重复计算

错误示例:for i in range(n): for j in range(len(lst))

优化:将len(lst)提前计算为变量

嵌套循环中修改外层变量

问题:内层循环意外修改外层循环变量

解决方案:使用不同变量名,或用enumerate避免直接操作索引

列表推导式:循环的优雅表达

列表推导式是Python对for循环的语法糖封装,用一行代码实现循环创建列表,兼具可读性与性能优势,是Python程序员必备技能。

〈一〉基本语法结构

标准格式
[表达式 for 变量 in 可迭代对象 if 条件]

等价于:

传统for循环写法
result = []
for 变量 in 可迭代对象:
    if 条件:
        result.append(表达式)

〔二〕列表推导式实战案例

① 简单映射
② 条件过滤
③ 嵌套循环生成

① 简单映射:计算平方

计算1~10的平方
squares = [x**2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

② 条件过滤:筛选偶数

提取1~20中的偶数
evens = [x for x in range(1, 21) if x % 2 == 0]
print(evens)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

③ 嵌套循环生成:矩阵展平

将3×3矩阵转为一维列表
matrix = [[1,2,3],[4,5,6],[7,8,9]]
flat = [item for row in matrix for item in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

⚡ 列表推导式 vs 传统循环

对比项 列表推导式 传统循环
代码行数 1行 4~5行
可读性 高(声明式) 中(命令式)
性能 快10%~20% 基准
适用复杂度 ≤2层嵌套 任意复杂度

💡 最佳实践

⑴ 简单映射/过滤用列表推导式

⑵ 复杂逻辑(多层嵌套、异常处理)用传统循环

⑶ 避免在推导式中使用print等副作用操作

循环性能优化:生产级实践指南

循环是程序性能瓶颈的高发区,合理优化可提升10倍以上执行效率。以下策略经实际项目验证,适用于中大型应用。

〈一〉避免重复计算

将循环内不变的计算移至循环外:

优化前
for i in range(1000000):
    x = len(data)  # 每次循环重复计算
    result.append(i * x)
优化后
data_len = len(data)
for i in range(1000000):
    result.append(i * data_len)

收益:消除O(n)次函数调用,n为循环次数

〔二〉选择高效迭代方式

优先使用range而非列表

for i in range(1000000)比for i in list(range(1000000))快3倍以上

字典遍历用.items()

for k, v in dict.items()比for k in dict: v = dict[k]快20%

列表遍历避免索引访问

for item in list比for i in range(len(list)): list[i]快15%

〔三〉使用生成器处理大数据

生成器替代列表
# 低效:生成完整列表
squares = [x*x for x in range(1000000)]
# 高效:惰性生成
squares_gen = (x*x for x in range(1000000))
for s in squares_gen:
    process(s)

内存对比:列表占用8MB+,生成器仅48字节

〔四〕向量化操作(进阶)

对数值计算,使用numpy替代原生循环:

numpy向量化计算
import numpy as np
# 原生循环
arr = list(range(1000000))
result = [x*2 for x in arr]
# numpy向量化
arr_np = np.arange(1000000)
result_np = arr_np * 2  # 自动广播

性能对比:numpy比原生循环快20~100倍

常见循环错误解析:避坑指南

根据Stack Overflow 2023数据,循环错误占Python问题的18%,以下是最常见5类错误及解决方案。

〈一〉IndexError:索引越界

错误代码:

items = [1, 2, 3]
for i in range(len(items)):
    print(items[i+1])  # i=2时访问items[3]越界

正确写法:

items = [1, 2, 3]
for i in range(len(items)-1):  # 或使用enumerate(items[:-1])

预防:优先使用enumerate(),避免手动索引

〔二〕ValueError:无法解包

错误代码:

for a, b in [(1,2), (3,)]:  # 第二个元组只有1个元素

正确写法:

for a, b in [(1,2), (3,4)]:  # 确保每个元组有2个元素

预防:使用zip()确保序列长度一致

〔三〕TypeError:不可迭代

错误代码:

for x in 123:  # 整数不可迭代

正确写法:

for x in str(123):  # 转为字符串

预防:检查变量类型,使用isinstance()验证

〔四〕死循环:条件永不为假

错误代码:

i = 0
while i < 5:
    print(i)
    # i未更新

预防:

  • ⑴ 在循环体开头添加断言验证条件收敛
  • ⑵ 使用超时机制(如time.time()限制执行时间)
  • ⑶ 开发时添加调试输出监控循环次数

〔五〕嵌套循环变量冲突

错误代码:

i = 0
for i in range(5):
    for i in range(3):  # 内层循环覆盖外层变量
        print(i)

正确写法:

i = 0
for i in range(5):
    for j in range(3):  # 使用不同变量名