Python 程序设计 · 第五章
for 与 whileLoop Structures & Batch Data Processing
将变动的数据与固定的处理逻辑解耦：
编写单次处理的通用规则，交由计算机按指定条件自动重复执行。
章节导入
GPA = Σ(学分×绩点) / Σ(学分)，每一步的中间结果都是下一步计算的基础。Python 两种循环语句：① for 循环：适合遍历范围已知、数量确定的数据（如顺着名单发通知、逐门课算学分）；② while 循环：适合重复次数未知、满足特定条件便继续的场景（如未达毕业学分要求时持续选课）。
5.1 案例说明 · 任务说明
依次向第 1、2、3 位学生发送秋季运动会通知，全部发完后打印一行汇总提示 通知发送完毕。
1、2、3）。print() 语句重复书写三遍？期望输出结果
向第 1 位学生发送运动会通知 向第 2 位学生发送运动会通知 向第 3 位学生发送运动会通知 通知发送完毕
核心目标：将“学生编号序列”与“发送单条通知的操作”解耦，交由循环自动重复执行。
5.1 案例代码 · 答案代码
for 循环重复执行顺序结构写法（重复书写三行）
print("向第 1 位学生发送运动会通知")
print("向第 2 位学生发送运动会通知")
print("向第 3 位学生发送运动会通知")for 循环写法（数据与操作解耦）
for student_id in range(1, 4):
print(f"向第 {student_id} 位学生发送运动会通知")
print("通知发送完毕")5.1.1 核心机制与重要说明
for 循环的迭代（Iteration）机制与变量命名range(1, 4) 序列取出当前整数，赋给循环变量 student_id。
重要说明（循环变量的命名）：student_id 是用户自定义变量名，并非内置关键字。修改名称时，循环内部引用也需同步调整。建议选用具有明确业务含义的名称（如 student_id、month、price），便于阅读与维护。
5.1.2 基本语法结构
for 循环语法模板、缩进规则与随堂练习for 循环变量 in range(起点, 终点):
循环体语句 1
循环体语句 2
...
循环结束后继续执行的语句for 与 in 为固定搭配关键字，行末英文冒号 : 标志循环体开始。for 左对齐时，表明已脱离循环体，属于循环全部结束后才执行的后续代码。5.1 随堂练习与核对：先后将 range(1, 4) 改为 range(1, 5) 和 range(7, 10)。
① range(1, 5) 依次输出编号 1, 2, 3, 4，加上末尾提示共 5 行；② range(7, 10) 依次输出编号 7, 8, 9，加上末尾提示共 4 行。
5.2.1 从起点取到终点
range() 左闭右开原则（含头不含尾）及两大优势打印 1 到 5 的整数（终点设为 6）
for number in range(1, 6):
print(number)1 2 3 4 5
[start, stop) 的两大优势stop - start。如 range(1, 6) 含 6 - 1 = 5 个数；全年 12 个月写作 range(1, 13)。range(1, 5) 与 range(5, 9) 两批时，前批取至 4、后批始于 5，分界点 5 不重不漏。核心准则：在步长为 1 的情况下，若希望循环包含整数 n，终点参数直接设为 n + 1。
5.2.1 思考与实践 · 任务说明
编写函数 print_triangle(n)，接收正整数参数 n，打印出由 n 行星号 * 组成的直角三角形。
*，第 2 行打印 2 个星号 **。i 行恰有 i 个星号（共输出 n 行）。i（即 "*" * i）可将该字符重复拼接 i 次。当 n = 4 时的期望输出
* ** *** ****
边界思考：要让行号变量依次取遍 1, 2, ..., n，range() 的终点参数应当如何设置？
5.2.1 思考与实践 · 答案代码
range(1, n + 1)PYTHON
def print_triangle(n):
for i in range(1, n + 1):
print("*" * i)
# 函数调用：打印 4 行直角三角形
print_triangle(4)关键要点：若误写为 range(1, n)，当传入 n = 4 时只会生成 1, 2, 3，导致最后一行（第 4 行）被遗漏（典型的“差一错误 Off-by-one Error”）。
5.2.2 起点、终点与步长
range() 的三种调用形式、负步长倒计时与参数限制| 语法形式 | 规则说明 | 示例 | 生成序列 |
|---|---|---|---|
range(stop) | 仅指定终点：默认从 0 开始，每次加 1（个数等于 stop） | range(4) | 0, 1, 2, 3 |
range(start, stop) | 指定起点与终点：默认每次加 1，不含终点 | range(1, 4) | 1, 2, 3 |
range(start, stop, step) | 同时指定起点、终点与步长（Step），不含终点 | range(1, 7, 2) | 1, 3, 5 |
负步长实现运动会倒计时（从 3 递减至 0 之前）
for remaining_days in range(3, 0, -1):
print(f"距开幕还有 {remaining_days} 天")运行结果（依次取出 3、2、1）
距开幕还有 3 天 距开幕还有 2 天 距开幕还有 1 天
重要说明（range 的参数限制）：参数必须均为整数。传入浮点数（如 range(1, 4, 0.5)）会引发 TypeError；若将步长设为 0（无法推进序列），则会引发 ValueError。
5.2.3 边界与空序列
| 表达式 | 生成的整数 | 执行次数 | 原因分析 |
|---|---|---|---|
range(1, 4) | 1, 2, 3 | 3 | 起点小于终点，每次加 1 向终点靠拢 |
range(4) | 0, 1, 2, 3 | 4 | 默认从 0 开始，每次加 1，共生成 4 个整数 |
range(3, 0, -1) | 3, 2, 1 | 3 | 起点大于终点，每次减 1 向终点靠拢 |
range(3, 3) | （无 / 空序列） | 0 | 起点等于终点，不含终点，无法取出任何数 |
range(3, 0) | （无 / 空序列） | 0 | 默认步长为 +1，从 3 递增无法到达 0 |
重要说明（空序列行为）：步长为正时生成数值须严格 < stop；步长为负时须严格 > stop。若起点不满足约束将生成空序列——Python 不会报错，而是直接跳过循环体，继续执行后续代码。5.2 随堂练习核对：打印 1~6 月写 range(1, 7)；打印 2、4、6 偶数月写 range(2, 7, 2)。
5.3.1 案例说明 · 任务说明
计算从 1 到正整数 n（如 n = 5）的所有整数之和并输出结果。
for 循环中，循环变量每轮都会被新取出的值覆盖。当 n = 5 时的期望输出
从 1 到 5 的整数之和：15
期初结余 + 本期发生额 = 期末结余
核心机制：每一步算出的中间累计结果，都是下一步继续累加的基础。
5.3.1 案例代码 · 答案代码
PYTHON（终点设为 n + 1 以包含 n）
n = 5
total = 0 # 累加器初始化：账面合计为 0
for number in range(1, n + 1):
total = total + number
print(f"从 1 到 {n} 的整数之和：{total}")| 阶段 | number | 累加前 | 算式 | 累加后 |
|---|---|---|---|---|
| 初始化 | — | — | 赋初值 0 | 0 |
| 第 1 轮 | 1 | 0 | 0 + 1 | 1 |
| 第 2 轮 | 2 | 1 | 1 + 2 | 3 |
| 第 3 轮 | 3 | 3 | 3 + 3 | 6 |
| 第 4 轮 | 4 | 6 | 6 + 4 | 10 |
| 第 5 轮 | 5 | 10 | 10 + 5 | 15 |
重要说明（赋值顺序与复合赋值简写）：total = total + number 先计算等号右侧表达式（读取旧值加上本轮数值），再写回左侧变量覆盖旧值。Python 中可简写为 total += number；计数器自增 1 可简写为 count += 1。
5.3.2 重要说明：初始化与输出位置
print() 输出粒度错误示范：在循环体内把累加器反复清零
n = 5
for number in range(1, n + 1):
total = 0 # 错误：每轮进入循环都先被重置为 0
total = total + number
print(f"错误的合计：{total}")错误的合计：5
5.3.3 案例说明 · 任务说明
检查 1 到 10 的所有整数，逐个打印其中能被 3 整除的数，并统计此类数值的总个数。
for 循环依次取出 1 至 10 的每个整数。number % 3 == 0）。count，每命中一个目标值便将其加 1。期望输出结果
3 6 9 能被 3 整除的数共有 3 个
结构组合范式：外层 for 循环负责“逐个取出候选数据”，内层 if 语句负责“按条件筛选处理”。
5.3.3 案例代码 · 答案代码
for 遍历 + 内层 if 条件筛选PYTHON
n = 10
count = 0 # 计数器初始化为 0
for number in range(1, n + 1):
if number % 3 == 0:
print(number)
count = count + 1 # 也可简写为 count += 1
print(f"能被 3 整除的数共有 {count} 个")重要说明（缩进决定统计口径）：若将 count += 1 减少一层缩进（改为与 if 左对齐），则无论是否被 3 整除每轮都会加 1，统计口径将从“符合条件的样本数（3 个）”错误变成“全部样本数（10 个）”。
5.3.4 应用案例 · 任务说明
某部门编制 3 个月季度预算：第 1 个月计划支出 1200 元，此后每月递增 100 元（依次为 1200、1300、1400 元）。
第 month 月支出 = 1200 + (month - 1) × 100期望输出结果
第 1 月：计划支出 1200 元 第 2 月：计划支出 1300 元 第 3 月：计划支出 1400 元 计划支出合计：3900 元 月均计划支出：1300.00 元
三步流程：① 循环准备（设参数与初值） → ② 逐轮迭代（算当月、累加、印明细） → ③ 退出汇总（印总额、算均值）。
5.3.4 应用案例 · 答案代码
PYTHON（循环准备 → 逐轮迭代 → 退出与汇总）
month_count = 3
total_cost = 0
for month in range(1, month_count + 1):
monthly_cost = 1200 + (month - 1) * 100
total_cost = total_cost + monthly_cost
print(f"第 {month} 月：计划支出 {monthly_cost} 元")
print(f"计划支出合计：{total_cost} 元")
if month_count > 0:
average_cost = total_cost / month_count
print(f"月均计划支出：{average_cost:.2f} 元")
else:
print("没有预算月份，无法计算月均支出")5.3.4 扩展实现
PYTHON（将“数据生成”与“数据统计”解耦）
month_count = 3
monthly_costs = [] # 创建空列表，用于保存各月支出明细
# 步骤 1：计算各月预算并存入列表
for month in range(1, month_count + 1):
cost = 1200 + (month - 1) * 100
monthly_costs.append(cost)
print(f"第 {month} 月：计划支出 {cost} 元")
# 步骤 2：直接遍历列表元素累加总额
total_cost = 0
for cost in monthly_costs:
total_cost += cost
print(f"计划支出合计：{total_cost} 元")5.4.1 案例说明 · 任务说明
某项目已有启动资金 1000 元，此后每月底固定追加 600 元。需经过几个月，储备资金才能达到或超过 2500 元？
range()？while 循环。期望输出结果
第 1 个月末：资金 1600.00 元 第 2 个月末：资金 2200.00 元 第 3 个月末：资金 2800.00 元 达到目标需要 3 个月
继续条件 vs 终止目标：终止目标是“达到 2500 元（>= 2500）”，故继续条件是“尚未达到 2500 元（reserve < target）”。
5.4.1 案例代码 · 答案代码
PYTHON
reserve = 1000
target = 2500
monthly_addition = 600
months = 0 # 计数器初始化：尚未开始月末追加时，月数为 0
while reserve < target:
reserve += monthly_addition
months = months + 1
print(f"第 {months} 个月末：资金 {reserve:.2f} 元")
print(f"达到目标需要 {months} 个月")动态重判机制：每轮循环体执行完毕后，程序自动返回 while 所在行，使用更新后的最新余额重新评估 reserve < target，直至条件变为 False 时跳出循环。
5.4.2 先检查条件，再执行循环体
while 循环语法结构与两个核心运行特征设定初始状态（初始化变量）
while 条件表达式:
条件成立时重复执行的业务语句
推进循环状态的更新语句
循环结束后继续执行的后续语句| 时机 | 判断前 | < 2500 | 执行动作与结果 |
|---|---|---|---|
| 第 1 次 | 1000 | True | 追加至 1600，months=1 |
| 第 2 次 | 1600 | True | 追加至 2200，months=2 |
| 第 3 次 | 2200 | True | 追加至 2800，months=3 |
| 第 4 次 | 2800 | False | 终止并退出循环 |
两个核心运行特征：① 先判断、后执行：若初始状态已达标（如 reserve = 3000），第 1 次检查即为 False，循环体一次也不执行（0 次），直接输出 0 个月；② 条件在每轮开始前重判，而非在循环体中间实时中断。
5.4.3 重要说明：必须更新状态变量
三大环节缺一不可：① 循环前设定初始状态 → ② 循环头检查继续条件 → ③ 循环内更新状态变量（推向终止边界）。
| 常见错误类型 | 错误代码特征 | 导致死循环的机理 | 正确修复方式 |
|---|---|---|---|
| 1. 遗漏状态更新 | 体内只打印提示，未写 reserve += ... | reserve 停留在 1000，条件恒为 True | 在循环体内补齐状态更新语句 |
| 2. 更新缩进错误 | 把 reserve += ... 写在与 while 左对齐处 | 更新语句脱离循环体，内部状态不推进 | 将更新语句缩进 4 个空格归入循环体 |
| 3. 步进方向反离 | 目标是涨到 2500，误写为 reserve -= ... | 资金越减越少，离 2500 越来越远 | 核对加减方向，确保每次向终止边界靠拢 |
| 4. 变量与条件脱节 | 判断 reserve < target，只更新 months += 1 | 被检查的 reserve 从未改变 | 确保体内更新的正是条件所依赖的变量 |
强行中断死循环的方法：若终端持续刷屏或卡死，在终端窗口按下快捷键 Ctrl + C（引发 KeyboardInterrupt），或点击编辑器右上角停止（Stop）按钮强行终止进程。
5.4.4 选择 for 还是 while
for 循环与 while 循环的选用依据及三环节对照| 循环类型 | 核心适用条件 | 典型应用场景 |
|---|---|---|
for 循环 | 重复次数事先确定，或待遍历数据集合已知 | 遍历 1~12 月、遍历学生名单、遍历固定列表计算汇总 |
while 循环 | 重复次数事先未知，需根据动态状态判断是否继续 | 资金累加至目标门槛、持续接收用户输入直至输入结束指令 |
固定次数任务对比：打印 1 到 3
# 方式一：for 循环（自动完成初始化、判断与步进）
for number in range(1, 4):
print(number)
# 方式二：while 循环（需手动编写三个环节）
number = 1 # 1. 初始化
while number <= 3: # 2. 条件判断
print(number)
number += 1 # 3. 手动步进凡是次数确定、范围已知的遍历任务，优先选用 for 循环，以精简代码并规避漏写步进语句导致死循环的风险。
5.4 随堂练习：将筹资 target 改为 2200（恰好达标→2个月）、2500（跨过目标→3个月）、1000（初始即达标→0个月）。
5.5.1 案例说明 · 任务说明
某产品销售单价为 50 元，单位变动成本为 30 元，固定成本总额为 1000 元。请在 1 至 200 件的整数销量范围内，找出使利润达到或超过 1000 元的最小销量。
利润 = (单价 - 单位变动成本) × 销量 - 固定成本查找结束。期望输出结果
首个达标销量：100 件 对应利润：1000 元 查找结束
break 语句：立即终止并跳出当前所在的那一层循环，直接转去执行循环下方的后续代码。
5.5.1 案例代码 · 答案代码
break 提前跳出循环与标志变量 foundPYTHON
unit_price = 50
unit_cost = 30
fixed_cost = 1000
target_profit = 1000
found = False # 标志变量初始化：查找开始前记为 False（尚未找到）
for quantity in range(1, 201):
profit = (unit_price - unit_cost) * quantity - fixed_cost
if profit >= target_profit:
found = True
print(f"首个达标销量：{quantity} 件")
print(f"对应利润：{profit} 元")
break
if not found:
print("在 1 至 200 件的范围内没有找到达标销量")
print("查找结束")5.5.2 案例说明 · 任务说明
某商品展销会为期 7 天（第 1 至第 7 天），其中第 3 天闭馆休整。开展期间每天需支付 80 元场地维护费，闭馆当天免收维护费。
期望输出结果
第 1 天开展 第 2 天开展 第 4 天开展 第 5 天开展 第 6 天开展 第 7 天开展 开展天数：6 天 维护费合计：480 元
continue 语句：立即结束当前这轮迭代，跳过循环体内其下方的剩余语句，直接开始下一轮迭代。
5.5.2 案例代码 · 答案代码
continue 跳过闭馆日及卫语句（Guard Clause）价值PYTHON
closed_day = 3
daily_cost = 80
open_days = 0
total_cost = 0
for day in range(1, 8):
if day == closed_day:
continue
open_days += 1
total_cost += daily_cost
print(f"第 {day} 天开展")
print(f"开展天数：{open_days} 天")
print(f"维护费合计：{total_cost} 元")5.5.3 & 5.5.4 重要说明与对比
continue 在 while 中的跳转陷阱 & 三种控制语句对比5.5.3 在 while 中使用 continue 的稳妥写法
record_no = 0
while record_no < 4:
record_no += 1 # 必须在 continue 前完成自增！
if record_no == 2:
continue
print(f"检查记录 {record_no}")for 与 while 中的跳转差异在 for 中执行 continue 会自动取下一元素；而在 while 中会直接跳回循环头检查条件——若把 record_no += 1 写在 continue 下方，自增将被跳过导致死循环！
| 控制语句 | 语法位置限制 | 中断范围 | 执行后跳转位置 | 典型使用场景 |
|---|---|---|---|---|
continue | 仅限循环体内 | 仅结束当前这轮迭代 | 回到本层循环开头，进入下一轮迭代 | 遇到闭馆日、缺失值等特殊数据时略过不计 |
break | 仅限循环体内 | 结束当前所在的那层循环 | 跳至该循环体下方的首条语句 | 已找到目标结果，无需继续测算剩余候选值 |
return | 仅限函数 def 内 | 结束整个函数的执行 | 带着返回值直接退回调用该函数的位置 | 无论嵌套几层循环，算出最终结果立即退出函数 |
5.6.1 & 5.6.2 在函数中组织循环
return 的正确放置位置def sum_integers(n: int) -> int:
"""返回从 1 到 n 的整数之和。"""
total = 0
for number in range(1, n + 1):
total += number
return total # 与 for 左对齐
print(sum_integers(5)) # 15
print(sum_integers(0)) # 0def incorrect_sum(n: int) -> int:
total = 0
for number in range(1, n + 1):
total += number
return total # 错误：第1轮加完1即退出
print(incorrect_sum(5)) # 1
print(incorrect_sum(0)) # None函数中 return 位置的两条原则：① 汇总统计类任务（求和、均值、计数）：必须等待循环全部完成，return 置于循环体外部；② 查找首个目标类任务（找最小达标销量、首笔超额订单）：找到即可终止，可将 return 置于循环体内的 if 分支中直接返回。
5.6.3 案例说明 · 任务说明
斐波那契数列规定：第 0 项为 0，第 1 项为 1；从第 2 项起，每一项均等于其前两项之和。请编写函数 fibonacci(n: int) -> int，返回第 n 项。
| 项号 n | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| 数列数值 | 0 | 1 | 1 | 2 | 3 | 5 | 8 | 13 |
核心规律与滑动窗口：第 2 项 1 = 0 + 1，第 3 项 2 = 1 + 1，第 4 项 3 = 1 + 2……推算下一项时，不需要记住前面所有历史项，只需维护紧邻的前两项，犹如两格宽的“滑动窗口”每次向右平移一格。
递推思考：如何用两个状态变量记录当前窗口中的前两项，并在每轮循环中安全地向右平移一格？
5.6.3 案例代码 · 答案代码
PYTHON（输出：0 1 1 13）
def fibonacci(n: int) -> int:
"""返回斐波那契数列第 n 项，第 0 项为 0。"""
previous = 0
current = 1
for step in range(n):
next_value = previous + current
previous = current
current = next_value
return previous
print(fibonacci(0), fibonacci(1), fibonacci(2), fibonacci(7))| 平移轮次 | previous | current | 对应的数列项 |
|---|---|---|---|
| 0（初始） | 0 | 1 | 第 0 项、第 1 项 |
| 1 | 1 | 1 | 第 1 项、第 2 项 |
| 2 | 1 | 2 | 第 2 项、第 3 项 |
| 3 | 2 | 3 | 第 3 项、第 4 项 |
| 4 | 3 | 5 | 第 4 项、第 5 项 |
| 5 | 5 | 8 | 第 5 项、第 6 项 |
重要说明：① 完成第 n 次平移后，previous 恰好保存第 n 项（n = 0 时直接返回初值 0）；② 必须先用临时变量 next_value 保存两项之和，再更新 previous 与 current，否则 previous 旧值会被提前覆盖！
核心内容 Part I 练习 1 · 任务说明
编写函数，接收非负整数 n，返回从 1 到 n 之间所有奇数的总和（包含边界奇数；当 n = 0 时返回 0）。
测试输入 n | 期望返回值 | 计算过程说明 |
|---|---|---|
0 | 0 | 范围内没有奇数，返回初始和 0 |
1 | 1 | 只有 1 这一个奇数 |
6 | 9 | 累加奇数：1 + 3 + 5 = 9 |
7 | 16 | 包含边界奇数：1 + 3 + 5 + 7 = 16 |
循环设计三问：① 定义什么变量保存累加状态？ ② 每轮如何更新它？ ③ range() 终点与步长如何设定？
核心内容 Part I 练习 1 · 答案代码
PYTHON
def sum_odd_numbers(n: int) -> int:
"""返回 1 至 n 中奇数的和，n 为非负整数。"""
total = 0
for number in range(1, n + 1, 2):
total += number
return total
print(sum_odd_numbers(0))
print(sum_odd_numbers(1))
print(sum_odd_numbers(6))
print(sum_odd_numbers(7))两种等价实现思路：除直接设置步长 range(1, n + 1, 2) 外，也可遍历 range(1, n + 1) 并在循环体内用 if number % 2 != 0: 筛选奇数累加；终点设为 n + 1 确保当 n 本身为奇数时包含在内。
核心内容 Part I 练习 2 · 任务说明
编写函数，接收初始资金、每月底追加金额和目标金额三个参数，使用 while 循环返回使累计资金达到或超过目标金额所需的最少整月数。
| 初始资金（元） | 每月追加（元） | 目标金额（元） | 期望月份数 | 业务场景说明 |
|---|---|---|---|---|
| 1000 | 600 | 2200 | 2 | 经过 2 个月末刚好攒到 2200 元 |
| 1000 | 600 | 2500 | 3 | 经过 3 个月末攒到 2800 元（跨过目标线） |
| 2500 | 600 | 2500 | 0 | 初始资金已刚好达标，无需等待 |
| 3000 | 600 | 2500 | 0 | 初始资金已超过目标，直接返回 0 |
边界要求：若初始资金本身已达到或超过目标金额，循环体不应执行，函数直接返回 0。
核心内容 Part I 练习 2 · 答案代码
while 循环动态测算达标月数PYTHON
def months_to_target(initial: int, monthly: int, target: int) -> int:
"""按整数元累计；初始资金和目标非负，每月追加额为正。"""
reserve = initial
months = 0
while reserve < target:
reserve += monthly
months += 1
return months
print(months_to_target(1000, 600, 2200))
print(months_to_target(1000, 600, 2500))
print(months_to_target(2500, 600, 2500))
print(months_to_target(3000, 600, 2500))核心内容 Part I 练习 3 · 任务说明
某企业采购同款办公用品：每购入一件，从剩余预算中扣减单价。当剩余预算不足以再买一件或采购件数达到库存上限时停止。
| 库存数量（件） | 单价（元） | 预算总额（元） | 期望采购件数 | 边界检查重点 |
|---|---|---|---|---|
| 10 | 80 | 250 | 3 | 买完 3 件后还剩 10 元，不够再买第 4 件 |
| 10 | 80 | 240 | 3 | 买完 3 件后预算刚好花光（剩 0 元） |
| 2 | 80 | 250 | 2 | 预算虽然还有富余，但库存总共只有 2 件 |
| 10 | 80 | 0 | 0 | 预算为 0 元，1 件也买不了 |
| 0 | 80 | 250 | 0 | 库存为 0 件，有钱也买不到 |
结构要求：请结合使用 for 循环、range()、break 语句与计数器变量，返回最多可采购件数。
核心内容 Part I 练习 3 · 答案代码
PYTHON
def count_affordable_items(stock: int, unit_price: int, budget: int) -> int:
"""返回可采购件数；库存和预算非负，单价为正，参数均为整数。"""
remaining = budget
item_count = 0
for attempt in range(stock):
if remaining < unit_price:
break
remaining -= unit_price
item_count += 1
return item_count
print(count_affordable_items(10, 80, 250))
print(count_affordable_items(10, 80, 240))
print(count_affordable_items(2, 80, 250))
print(count_affordable_items(10, 80, 0))
print(count_affordable_items(0, 80, 250))核心内容 Part I 练习 4 · 任务说明
错误代码（省去了临时变量，输出 4 而非 2）
def incorrect_fibonacci(n: int) -> int:
previous = 0
current = 1
for step in range(n):
previous = current
current = previous + current
return previous
print(incorrect_fibonacci(3)) # 输出 4| 已完成轮次 | previous 当前值 | current 当前值 |
|---|---|---|
| 0（初始状态） | 0 | 1 |
| 1 | 待填写 | 待填写 |
| 2 | 待填写 | 待填写 |
| 3 | 待填写 | 待填写 |
排查要求：按赋值顺序填表定位偏离轮次，修正代码，并解释为何仅测试 n = 1 时无法发现该错误？
核心内容 Part I 练习 4 · 答案代码
| 已完成轮次 | previous | current | 错误发生过程分析 |
|---|---|---|---|
| 0（初始） | 0 | 1 | 初始状态正常 |
| 1 | 1 | 2 | 先执行 previous = current 变为 1；再算 current = 1 + 1 变为 2（旧值 0 被覆盖） |
| 2 | 2 | 4 | 先执行 previous = current 变为 2；再算 current = 2 + 2 变为 4 |
| 3 | 4 | 8 | 先执行 previous = current 变为 4；再算 current = 4 + 4 变为 8（每轮翻倍） |
修正后代码（测试 0, 1, 2, 3, 6 → 输出 0, 1, 1, 2, 8）
def fibonacci(n: int) -> int:
previous = 0
current = 1
for step in range(n):
next_value = previous + current
previous = current
current = next_value
return previous为何 n = 1 无法发现错误？
第 1 轮结束后 previous 为 1，函数返回的 previous 恰好与真实值巧合重合！
测试循环函数应至少覆盖：循环 0 次、循环 1 次、多轮连续迭代三种场景。
核心内容 Part II · 5.7 列表基本操作
.append() 追加| Part II 递进层次 | 对应小节 | 核心内容与应用场景 |
|---|---|---|
| 1. 列表基础与遍历 | 5.7、5.8 | 用列表存放离散订单或流水数据，配合 for 循环完成汇总、筛选与核算 |
| 2. 组合方案推演 | 5.9 | 用双层嵌套循环遍历“价格 × 销量”组合网格，测算多方案利润 |
| 3. 遍历辅助工具 | 5.10、5.11 | 用 enumerate() 同时获取序号与数据；掌握循环 else 子句的执行逻辑 |
| 4. 交互式持续录入 | 5.12 | 用 while True 配合哨兵值，实现“逐笔键盘录入 + 事后统一汇总” |
5.7.1 定义列表 [] 与 len() & 5.7.2 .append() 追加
order_amounts = [85.0, 99.0, 120.0]
print(order_amounts, len(order_amounts)) # [85.0, 99.0, 120.0] 3
expenses = []
expenses.append(25.0)
expenses.append(68.5)
print(expenses, len(expenses)) # [25.0, 68.5] 2.append() 属于原地修改（In-place Mutation），直接改变原列表，其方法返回值为 None。
切勿写成 expenses = expenses.append(25.0)，否则列表变量会被 None 覆盖！
5.7.3 按位置取值
0 开始：偏移量原理与越界防范| 日常表述 | Python 索引 | 取值表达式 | 读取金额 |
|---|---|---|---|
| 第 1 笔订单 | 0 | order_amounts[0] | 85.0 元 |
| 第 2 笔订单 | 1 | order_amounts[1] | 99.0 元 |
| 第 3 笔订单 | 2 | order_amounts[2] | 120.0 元 |
按位置索引读取元素
order_amounts = [85.0, 99.0, 120.0]
print(f"第一笔金额：{order_amounts[0]:.2f} 元")
print(f"第三笔金额：{order_amounts[2]:.2f} 元")第一笔金额：85.00 元 第三笔金额：120.00 元
重要说明（偏移量与越界异常）：索引代表当前元素距离列表首地址的偏移量（Offset），故从 0 起编。长度为 3 的列表合法正向索引为 0, 1, 2（最大为 len - 1）；读取 order_amounts[3] 或空列表 empty_list[0] 将抛出 IndexError: list index out of range。
5.8.1 直接取得每一个元素
直接遍历列表元素
expenses = [25.0, 68.5, 16.5]
for expense in expenses:
print(f"支出：{expense:.2f} 元")
print("支出明细输出完毕")支出：25.00 元 支出：68.50 元 支出：16.50 元 支出明细输出完毕
for 循环变量 in 可迭代对象:
针对当前取出的元素执行处理循环变量 expense 直接接收元素本身的具体数值，而非位置索引。
遍历（Traversal）：按顺序访问容器中所有元素的过程。
可迭代对象（Iterable）：可放在 for ... in 之后逐项提供元素的对象（如 range、列表、字符串、字典等）。
5.8.2 案例说明 · 任务说明
某门店记录了连续 4 天的日营业额列表：sales_records = [1200.0, -1.0, 0.0, 1500.0]。请剔除漏报记录，统计并输出已上报天数、已上报销售额合计与日均销售额。
>= 0.0），其中 0.0 代表当天正常营业但收入为 0。-1.0。期望输出结果
已上报天数：3 天 已上报销售额合计：2700.00 元 已上报日期的平均销售额：900.00 元
核心注意点：计算日均营业额时，分母应当是“有效上报天数（3 天）”还是“列表总长度（4 项）”？
5.8.2 案例代码 · 答案代码
PYTHON
sales_records = [1200.0, -1.0, 0.0, 1500.0]
total_sales = 0.0
valid_count = 0 # 仅统计正常上报的有效天数
for sales in sales_records:
if sales == -1.0:
continue
total_sales += sales
valid_count += 1
print(f"已上报天数：{valid_count} 天")
print(f"已上报销售额合计：{total_sales:.2f} 元")
if valid_count > 0:
average_sales = total_sales / valid_count
print(f"已上报日期的平均销售额：{average_sales:.2f} 元")
else:
print("没有有效记录，无法计算平均值")5.8.3 案例说明 · 任务说明
某平台规定单笔订单满 99 元免运费，不足 99 元加收 6 元运费。现有一批订单金额列表 [85.0, 99.0, 120.0]，请逐笔计算实付金额并汇总总额。
calculate_payment(order_amount)，负责单笔运费判断。calculate_batch_payment(order_amounts)，在循环中调用单笔函数完成总额核算。期望输出结果
批量实付合计：310.00 元 空批次实付合计：0.00 元
三笔订单实付分别为 91.0、99.0 与 120.0 元，合计 310.00 元。
设计思考：将“单笔计费规则”与“列表遍历汇总”拆分为两个独立函数，在工程维护上有什么优势？
5.8.3 案例代码 · 答案代码
PYTHON
def calculate_payment(order_amount: float) -> float:
"""计算单笔订单的实付金额，输入为非负商品金额。"""
if order_amount >= 99.0:
shipping_fee = 0.0
else:
shipping_fee = 6.0
return order_amount + shipping_fee
def calculate_batch_payment(order_amounts: list) -> float:
"""计算批量订单的实付金额总计；空列表返回 0.0。"""
total_payment = 0.0
for amount in order_amounts:
payment = calculate_payment(amount)
total_payment += payment
return total_payment
print(f"批量实付合计：{calculate_batch_payment([85.0, 99.0, 120.0]):.2f} 元")
print(f"空批次实付合计：{calculate_batch_payment([]):.2f} 元")5.9.1 案例说明 · 任务说明
已知单位变动成本 30.0 元，固定成本 1000.0 元。请测算候选单价 prices = [50.0, 60.0] 与候选销量 quantities = [100, 200] 两两组合下的全部利润表现。
利润 = (销售单价 - 单位变动成本) × 销售数量 - 固定成本2 × 2 = 4 种组合）。期望输出结果
单价 50.00 元，销量 100 件，利润 1000.00 元 单价 50.00 元，销量 200 件，利润 3000.00 元 单价 60.00 元，销量 100 件，利润 2000.00 元 单价 60.00 元，销量 200 件，利润 5000.00 元
嵌套循环（Nested Loop）：在一个循环的循环体内部再包含另一个循环，用于处理二维组合遍历问题。
5.9.1 案例代码 · 答案代码
PYTHON
prices = [50.0, 60.0]
quantities = [100, 200]
unit_cost = 30.0
fixed_cost = 1000.0
for price in prices:
for quantity in quantities:
profit = (price - unit_cost) * quantity - fixed_cost
print(f"单价 {price:.2f} 元，销量 {quantity} 件，利润 {profit:.2f} 元")| 序号 | 外层 price | 内层 quantity | 算出 profit |
|---|---|---|---|
| 1 | 50.0 元 | 100 件 | 1000.00 元 |
| 2 | 50.0 元 | 200 件 | 3000.00 元 |
| 3 | 60.0 元 | 100 件 | 2000.00 元 |
| 4 | 60.0 元 | 200 件 | 5000.00 元 |
重要说明（时针与分针节奏）：外层循环每前进一步，内层循环均需从头到尾完整执行一轮。双层嵌套循环实现两列表元素的全组合（笛卡尔积），内层总执行次数 = 外层长度 × 内层长度（2 × 2 = 4 次）。
5.9.2 案例说明 · 任务说明
候选单价 prices = [50.0, 60.0]，升序候选销量 quantities = [100, 200, 300]，单位变动成本 30.0 元，固定成本 1000.0 元。
2500.0 元的销量。期望输出结果
单价 50.00 元：首个达标候选销量为 200 件 单价 60.00 元：首个达标候选销量为 200 件
核心问题：在内层循环中执行 break 时，它会跳出整个双层循环，还是仅跳出内层循环？
5.9.2 案例代码 · 答案代码
break 只结束最内层循环PYTHON
prices = [50.0, 60.0]
quantities = [100, 200, 300]
unit_cost = 30.0
fixed_cost = 1000.0
target_profit = 2500.0
for price in prices:
for quantity in quantities:
profit = (price - unit_cost) * quantity - fixed_cost
if profit >= target_profit:
print(f"单价 {price:.2f} 元：首个达标候选销量为 {quantity} 件")
break重要说明（嵌套循环中 break 的作用范围）：在嵌套循环中，break 仅终止并跳出其直接所在的最内层循环，外层循环将继续正常推进下一轮。同理，continue 也仅跳过最内层循环的当前轮次。
5.10 同时获取序号和元素
enumerate() 与解包（Unpacking）使用 enumerate(expenses, start=1) 编号打印
expenses = [25.0, 68.5, 16.5]
for item_no, expense in enumerate(expenses, start=1):
print(f"第 {item_no} 笔支出：{expense:.2f} 元")第 1 笔支出：25.00 元 第 2 笔支出：68.50 元 第 3 笔支出：16.50 元
| 迭代轮次 | item_no（序号） | expense（元素） |
|---|---|---|
| 第 1 轮 | 1 | 25.0 |
| 第 2 轮 | 2 | 68.5 |
| 第 3 轮 | 3 | 16.5 |
重要说明（解包与起始编号）：① enumerate() 每轮产出一对数据 (序号, 元素)，for item_no, expense in ... 将其分别赋给两个变量，称为解包（Unpacking）；② 省略 start 时默认从 0 起编；日常报表打印建议显式传入 start=1。
5.11 案例说明 · 任务说明
break 中断时：信贷逾期记录排查给定某客户近三期账单的逾期天数列表 overdue_days = [0, 0, 0]（0 表示按时还款，正整数表示逾期天数）。请排查是否存在逾期记录。
days > 0），立即打印 发现逾期记录：逾期 X 天 并使用 break 终止检查。未发现逾期记录；最后统一打印 检查结束。当列表为 [0, 0, 0] 时的期望输出
未发现逾期记录 检查结束
Python 语法特性：for 和 while 循环后均可接一个同级缩进的 else: 子句，专门处理“未触发 break”的情形。
5.11 案例代码 · 答案代码
else 子句：本质是 no_break（若未触发 break）PYTHON（注意 else: 与 for 垂直左对齐）
overdue_days = [0, 0, 0]
for days in overdue_days:
if days > 0:
print(f"发现逾期记录：逾期 {days} 天")
break
else:
print("未发现逾期记录")
print("检查结束")输入列表 overdue_days | 循环结束方式 | 执行 else？ |
|---|---|---|
[0, 0, 0]（正常） | 3 项检查完毕，未触发 break | 执行 |
[0, 12, 0]（逾期） | 第 2 项触发 break 跳出 | 不执行 |
[]（空列表） | 列表为空，未触发 break 结束 | 执行 |
重要说明（切勿将循环 else 误解为“循环未执行”）：当输入 [0, 0, 0] 时，循环完整执行了 3 次，依然进入 else！应将其理解为 no_break：只要中途未触发 break，循环自然结束时均执行 else。工程实践中也可自主选用标志变量 found = False 或函数内直接 return。
5.12 案例说明 · 任务说明
哨兵值（Sentinel Value）：约定一个正常业务中不可能出现的特殊数值作为终止信号（本身不属于业务数据）。
>= 0）。-1 代表结束录入（哨兵值）。金额不能为负，请重新输入 并继续录入。依次输入 120, -2, 0, 80, -1 的交互过程
请输入一天的销售额（-1 结束）：120 请输入一天的销售额（-1 结束）：-2 金额不能为负，请重新输入 请输入一天的销售额（-1 结束）：0 请输入一天的销售额（-1 结束）：80 请输入一天的销售额（-1 结束）：-1 已上报天数：3 天 已上报销售额合计：200.00 元
5.12 案例代码 · 答案代码
PYTHON（阶段 1：while True 循环录入 → 阶段 2：for 遍历汇总）
sales_records = []
while True:
amount = float(input("请输入一天的销售额（-1 结束）："))
if amount == -1.0:
break
if amount < 0.0:
print("金额不能为负，请重新输入")
continue
sales_records.append(amount)
total_sales = 0.0
for amount in sales_records:
total_sales += amount
record_count = len(sales_records)
print(f"已上报天数：{record_count} 天")
print(f"已上报销售额合计：{total_sales:.2f} 元")核心内容 Part II 练习 1 · 任务说明
单位变动成本 30.0 元，固定成本 1000.0 元。候选单价列表 prices = [50.0, 60.0]，候选销量列表 quantities = [100, 200, 300]，目标利润设为 3000.0 元。
3000.0 元的方案明细，并在最后输出达标方案的总个数。期望输出结果
单价 50.00 元，销量 200 件，利润 3000.00 元 单价 50.00 元，销量 300 件，利润 5000.00 元 单价 60.00 元，销量 200 件，利润 5000.00 元 单价 60.00 元，销量 300 件，利润 8000.00 元 达标方案：4 个
对比思考：本题要求列出“全部达标方案”，与 5.9.2 节“找首个达标销量”相比，内层循环还能加 break 吗？
核心内容 Part II 练习 1 · 答案代码
PYTHON
prices = [50.0, 60.0]
quantities = [100, 200, 300]
unit_cost = 30.0
fixed_cost = 1000.0
target_profit = 3000.0
plan_count = 0
for price in prices:
for quantity in quantities:
profit = (price - unit_cost) * quantity - fixed_cost
if profit >= target_profit:
plan_count += 1
print(f"单价 {price:.2f} 元，销量 {quantity} 件，利润 {profit:.2f} 元")
print(f"达标方案：{plan_count} 个")核心内容 Part II 练习 2 · 任务说明
编写函数，接收订单金额列表 order_amounts 与审核门槛 threshold，使用 enumerate(..., start=1) 返回首笔严格超过（>）门槛的订单编号；若均未超标或为空列表，返回 0。
订单金额列表 order_amounts | 审核门槛 threshold | 期望返回编号 | 业务场景说明 |
|---|---|---|---|
[500.0, 1000.0, 1200.0, 1500.0] | 1000.0 | 3 | 第 2 笔恰好等于 1000.0 不算超标，第 3 笔首次超标 |
[1200.0, 500.0] | 1000.0 | 1 | 第 1 笔即超标，立即返回 1 |
[500.0, 1000.0] | 1000.0 | 0 | 无严格大于 1000.0 的订单，遍历完毕后返回 0 |
[] | 1000.0 | 0 | 空列表无数据，循环不执行，直接返回 0 |
边界核对：注意“严格超过”对应比较运算符 >（恰好等于门槛金额不算超标）。
核心内容 Part II 练习 2 · 答案代码
returnPYTHON
def find_first_large_order(order_amounts: list, threshold: float) -> int:
"""返回首笔严格超过门槛的订单编号，未找到时返回 0。"""
for order_no, amount in enumerate(order_amounts, start=1):
if amount > threshold:
return order_no
return 0
print(find_first_large_order([500.0, 1000.0, 1200.0, 1500.0], 1000.0))
print(find_first_large_order([1200.0, 500.0], 1000.0))
print(find_first_large_order([500.0, 1000.0], 1000.0))
print(find_first_large_order([], 1000.0))顺序查找紧凑范式：在函数内部查找首个目标时，命中即 return，循环外末尾兜底 return 0，无需额外定义 found 标志变量或手写 break。
核心内容 Part II 练习 3 · 任务说明
在 5.12 节交互录入程序的基础上，在末尾补充计算已上报日期平均销售额的代码（输入 -1 结束录入；输入其他负数提示重输；输入非负数存入列表）。
-1，不得执行除法，打印提示：没有有效记录，无法计算平均值。| 依次从键盘输入的数字序列 | 已上报天数 | 销售额合计 | 期望输出的平均销售额或提示 |
|---|---|---|---|
120, -2, 0, 80, -1 | 3 天 | 200.00 元 | 66.67 元 |
0, -1 | 1 天 | 0.00 元 | 0.00 元 |
-1 | 0 天 | 0.00 元 | 没有有效记录，无法计算平均值 |
核心内容 Part II 练习 3 · 答案代码
PYTHON
sales_records = []
while True:
amount = float(input("请输入一天的销售额（-1 结束）："))
if amount == -1.0:
break
if amount < 0.0:
print("金额不能为负，请重新输入")
continue
sales_records.append(amount)
total_sales = 0.0
for amount in sales_records:
total_sales += amount
record_count = len(sales_records)
print(f"已上报天数：{record_count} 天")
print(f"已上报销售额合计：{total_sales:.2f} 元")
if record_count > 0:
average_sales = total_sales / record_count
print(f"已上报日期的平均销售额：{average_sales:.2f} 元")
else:
print("没有有效记录，无法计算平均值")本章回顾（一）
循环核心执行三阶段：① 循环前初始化状态变量 → ② 循环中按步推进状态变量 → ③ 循环后输出或返回计算结果
| 业务需求与场景 | 推荐写法或结构 | 关键原理与防错提醒 |
|---|---|---|
| 创建空列表并逐笔追加 | 先写 items = []，再用 items.append(x) | .append() 是原地修改，切勿写成 items = items.append(x) |
| 按位置读取列表元素 | items[0]、items[1] | 索引表示偏移量，从 0 开始编号，注意防止越界 |
| 从头到尾处理列表数据 | for item in items: | 循环变量直接接收元素本身，无需通过索引间接读取 |
| 按规律生成整数序列重复 | for i in range(start, stop, step): | 左闭右开（含头不含尾）；要包含整数 n，终点写 n + 1 |
| 未知次数、达标才停止 | while 条件表达式: | 循环体内必须包含状态更新语句，使变量逐步靠近终止条件 |
| 计算总额或统计笔数 | 循环外初始化为 0，循环内逐步累加 | 切勿将初始化写进循环体内，否则每轮都会被重置为 0 |
本章回顾（二）
| 业务需求与场景 | 推荐写法或结构 | 关键原理与防错提醒 |
|---|---|---|
| 仅处理符合条件的数据 | 循环体内嵌套 if 分支 | 注意缩进层级：缩进在 if 内部的语句才受条件控制 |
| 略过特殊数据继续下一轮 | 循环体内使用 continue | 仅跳过本轮剩余语句；在 while 中切勿跳过步进更新语句 |
| 找到目标后提前结束循环 | 循环体内使用 break | 立即跳出当前最内层循环，外层循环继续正常执行 |
| 函数中找到结果立即返回 | 函数内部循环中使用 return | 立即结束整个函数调用；若算汇总值，return 须置于循环外 |
| 同时获取序号与元素 | for no, item in enumerate(items, start=1): | 成对解包获取序号与元素，省去手动维护计数器的步骤 |
| 测算“价格×销量”全组合 | 双层嵌套循环 | 外层走一步，内层转一轮；总执行次数等于两列表长度相乘 |
五类必查边界情况：① 空数据（[]、月数为 0、直接输入 -1 防除零/越界）；② 单条数据（n = 1）；③ 临界值数据（恰好等于 99 元或目标值，核对 < 与 <=）；④ 全都不达标（验证 found 或默认返回值）；⑤ 初始即达标（while 能否直接返回 0）。
补充说明（Tips）
sum()提示 1：循环变量、块作用域与只读遍历
• 勿在 for 体内改循环变量：下轮仍被序列覆盖；跨步用步长。
• 无块作用域：循环后要用的变量须在循环前初始化。
• 遍历中勿直接删列表元素：会导致后续元素前移漏算。
提示 2：浮点数精度误差与财务金额口径
• 二进制浮点下 0.1 + 0.2 == 0.30000000000000004。
• 铁律：勿用浮点 ==/!= 作 while 条件；金融宜转整数“分”或用 Decimal。
• :.2f 仅格式化显示文本，不改变内存精度。
提示 3：内置函数 sum() 直接求和（输出 4000.00 元）
daily_sales = [1200.0, 1500.0, 1300.0]
total_sales = sum(daily_sales)
print(f"销售额合计：{total_sales:.2f} 元")何时用 sum()，何时手写循环？
现有序列原样无条件相加直接调用 sum()；一旦涉及跳过 -1.0 漏报（5.8.2）、先算单笔运费再汇总（5.8.3）或达预算上限提前 break（练习 3），必须手写循环控制条件筛选与状态更新。