《计算机程序设计基础》随堂测验（A 卷）：试题与参考解答

更新时间: 2026-10-25 23:01 · 中文版
目录 (13)

Language / 语言：English Version | 中文版

西南财经大学 | Instructor: Luping Zhang | 考试日期： 2026年10月21日 | 试卷类型：【A 卷】（SWUFE-20261021-QUIZ1-A）

答题说明：

  1. 请在上方表格内清晰工整地填写姓名、学号并勾选所在 Session。
  2. 设计程序时，请根据业务场景合理设计变量、流程与函数（发现并设计独立的系统单元），遵循课程命名规范与数据类型标注规范。答案不唯一，按设计的科学性与合理性给分。
  3. 在答题纸上每道小题对应的答题区域作答，保持代码缩进层级清晰，符合Python规范。
  4. 可使用中文或者英语作答。

[Q1] 第一题

题目描述

阅读以下 Python 代码：

python 
base_price = 100.0
discount = 20.0
final_price = base_price - discount

if final_price >= 60.0:
    final_price = final_price - 10.0

print(final_price)

结合左侧代码与所学知识，回答以下问题：

  • [Q1.1] 阐述Python执行上述代码时的每个步骤及内存模型。
  • [Q1.2] 阐述代码块的概念、代码块的结构以及核心特征，并举例说明常见的代码块。

[Q1.1] 参考解答

1. Python 内存模型概述

在本课程的模型中，Python 通过两个部分管理内存中的变量与数据：变量表记录程序中定义的变量名，数据存储单元存放具体的数据值（如 100.0、20.0、80.0 和 70.0）。

变量表中的变量与数据存储单元中的值通过内存地址绑定。执行赋值语句（变量 = 表达式）时，Python 先计算等号右侧表达式的值，将所得结果存入数据存储单元，再将该值与等号左侧的变量绑定。对已有变量重新赋值时，Python 会将新值存入另一个数据存储单元，并将该变量重新绑定到新值。

2. 逐步执行过程

  1. 第 1 行（base_price = 100.0，初始赋值）：

    • Python 先计算等号右侧的 100.0，将 100.0 存入数据存储单元，再将数值 100.0 与变量 base_price 绑定。

  2. 第 2 行（discount = 20.0，初始赋值）：

    • Python 先计算等号右侧的 20.0，将 20.0 存入数据存储单元，再将数值 20.0 与变量 discount 绑定。

  3. 第 3 行（final_price = base_price - discount，表达式求值与绑定）：

    • Python 先计算等号右侧的 base_price - discount：读取 base_price 绑定的值（100.0）和 discount 绑定的值（20.0），算出 100.0 - 20.0 = 80.0。
    • 随后将 80.0 存入数据存储单元，并将数值 80.0 与变量 final_price 绑定。

  4. 第 5 行（if final_price >= 60.0:，条件判断）：

    • Python 读取 final_price 当前绑定的值（80.0），判断比较表达式 80.0 >= 60.0。由于条件为 True，执行流进入第 6 行缩进的 if 代码块主体。

  5. 第 6 行（ final_price = final_price - 10.0，重新赋值）：

    • Python 先利用 final_price 当前绑定的值（80.0）计算等号右侧的 final_price - 10.0，得出 80.0 - 10.0 = 70.0。
    • 随后将 70.0 存入新的数据存储单元，并将新值 70.0 重新绑定给 final_price（替代原先与 80.0 的绑定）。

  6. 第 8 行（print(final_price)，退出代码块与屏幕输出）：

    • 由于代码缩进恢复至最左侧，执行流退出 if 代码块，回到主流程。Python 读取 final_price 当前绑定的值（70.0），并在终端打印 70.0。
    • 终端输出：
      text 
      70.0

3. 内存模型示意图

text 
+-------------------------------------------------------------------+
|                           内存模型示意图                          |
|                （变量与数值通过内存地址建立绑定）                 |
+-------------------------------+-----------------------------------+
|            变量表             |            数据存储单元           |
+-------------------------------+-----------------------------------+
|                               |                                   |
|   base_price   ---------------------->  [ 100.0 ]                 |
|                               |                                   |
|   discount     ---------------------->  [  20.0 ]                 |
|                               |                                   |
|   final_price  -------x-------------->  [  80.0 ]  （第 3 行）    |
|                   |           |                                   |
|                   +------------------>  [  70.0 ]  （第 6 行）    |
|               （重新绑定）    |                                   |
+-------------------------------+-----------------------------------+

[Q1.2] 参考解答

1. 代码块的概念

在 Python 中，代码块是由首部行和缩进主体构成的独立逻辑结构，它将一组语句组织并统辖为一个执行整体。

2. 代码块的结构

代码块具有固定的两段式结构（首部 + 主体）：

text 
关键字首部语句:                    # 第一部分：首部（以英文冒号 ':' 结尾）
    主体语句_1                     # 第二部分：主体（向右缩进 4 个空格）
    主体语句_2                     # 第二部分：主体（对齐在 4 个空格处）
    ...

后续语句                           # 代码块外部（恢复缩进层级）
  1. 首部行：首部以关键字（如 if、elif、else、def、for 或 while）开头，声明控制条件或定义规则，并以英文冒号（:）结尾。
  2. 主体：主体紧跟首部之后，由一行或多行缩进语句组成（每个缩进层级为 4 个空格）。后续行恢复到首部所在的缩进层级时，代码块即告结束。

3. 核心特征

  1. 结构固定且不可分割：代码块具有固定的语法形态（首部 + 缩进主体），构成一个完整的结构整体：两部分必须成对出现，任何一部分都不能单独存在。
  2. 作为整体统一执行：代码块构成单一的执行单元，其中的语句要么按顺序一并执行，要么作为整体一并跳过。
  3. 以缩进界定边界：Python 依靠缩进组织语句。主体中同一逻辑层级的语句必须保持相同的缩进量；恢复到首部的缩进层级即退出当前代码块。
  4. 支持层级嵌套：由于代码块本身是自包含的单元，可以在外层代码块的主体内部通过加深缩进嵌入完整的内层代码块（首部 + 主体）。

4. 常见代码块示例

  1. 条件分支代码块（if / elif / else）：
    python 
    if final_price >= 60.0:              # 首部
    final_price = final_price - 10.0 # 主体
  2. 函数定义代码块（def）：
    python 
    def calculate_subtotal(unit_price: float, quantity: int) -> float:  # 首部
    return unit_price * quantity                                    # 主体
  3. 循环代码块（for / while）：
    python 
    for day in range(1, 4):              # 首部
    print(f"Day {day}")              # 主体

[Q2] 第二题

题目描述

某跨境物流企业提供空运、陆运和航运服务。本题中，三种运输方式采用相同的运费计算规则：货物的体积折算成体积重量（公斤），为其体积（立方厘米）除以 6000；计费重量取实际重量与体积重量中的较大值；运费为计费重量乘以对应运输方式的运费单价。

三种运输方式的运费单价见表1，现有三件货物的信息见表2。

表1：运费单价

运输方式 单价（元/公斤）
空运 8.5
陆运 3.0
航运 1.5

表2：货物信息

运输方式 体积（立方厘米） 实际重量（公斤）
空运 120000 15
陆运 3000 2.5
航运 500000 120
  • [Q2.1] 针对上述业务场景，合理划分运费结算系统的功能，并编写相应的 Python 函数。调用所设计的函数，分别计算并输出表2中三件货物各自的运费。
  • [Q2.2] 按照讲义中的“系统”模型，绘制上述程序的系统结构图。

[Q2.1] 参考解答一（两阶段流水线：2 个函数）

1. 功能划分

运费计算可划分为两个函数（系统），第一个函数的输出作为第二个函数的输入：

  1. cal_chargeable_weight(volume: float, actual_weight: float) -> float：接收货物体积与实际重量，计算体积重量（volume / 6000.0），并返回实际重量与体积重量中的较大值（chargeable_weight）。
  2. cal_shipping_charge(chargeable_weight: float, mode: str) -> float：接收 chargeable_weight（cal_chargeable_weight 的输出）与运输方式 mode，选取对应的运费单价，并返回运费（chargeable_weight * rate）。

2. Python 代码

python 
# 函数 1：根据体积与实际重量计算计费重量
def cal_chargeable_weight(volume: float, actual_weight: float) -> float:
    volumetric_weight = volume / 6000.0
    if volumetric_weight >= actual_weight:
        chargeable_weight = volumetric_weight
    else:
        chargeable_weight = actual_weight
    return chargeable_weight


# 函数 2：根据计费重量与运输方式计算运费
def cal_shipping_charge(chargeable_weight: float, mode: str) -> float:
    if mode == "空运":
        rate = 8.5
    elif mode == "陆运":
        rate = 3.0
    elif mode == "航运":
        rate = 1.5
    else:
        print("运输方式不正确！")
        return -1.0  # 异常标识值
    shipping_charge = chargeable_weight * rate
    return shipping_charge


# 分别计算并输出表 2 中三件货物的运费
weight_air = cal_chargeable_weight(120000.0, 15.0)
charge_air = cal_shipping_charge(weight_air, "空运")
print(f"空运货物运费: {charge_air:.2f} 元")

weight_land = cal_chargeable_weight(3000.0, 2.5)
charge_land = cal_shipping_charge(weight_land, "陆运")
print(f"陆运货物运费: {charge_land:.2f} 元")

weight_sea = cal_chargeable_weight(500000.0, 120.0)
charge_sea = cal_shipping_charge(weight_sea, "航运")
print(f"航运货物运费: {charge_sea:.2f} 元")

[Q2.2] 参考解答一

每个函数都是一个输入-处理-输出（IPO）系统，系统 1 的输出（chargeable_weight）直接作为输入传递给系统 2：

系统结构图：运费结算（IPO 模型）

[Q2.1] 参考解答二（1 个工具函数 + 3 个业务函数）

1. 功能划分

该计算也可划分为 1 个工具函数与 3 个业务函数：

  1. 工具函数（cal_chargeable_weight）：接收 volume 和 actual_weight，计算体积重量（volume / 6000.0），并返回实际重量与体积重量中的较大值（chargeable_weight）。
  2. 业务函数（cal_air_shipping_charge、cal_land_shipping_charge 和 cal_sea_shipping_charge）：各函数分别接收 volume 和 actual_weight，调用 cal_chargeable_weight(volume, actual_weight) 获取计费重量，再乘以对应运输方式的单价（分别为 8.5、3.0 和 1.5）。

2. Python 代码

python 
# 工具函数：根据体积与实际重量计算计费重量
def cal_chargeable_weight(volume: float, actual_weight: float) -> float:
    volumetric_weight = volume / 6000.0
    if volumetric_weight >= actual_weight:
        chargeable_weight = volumetric_weight
    else:
        chargeable_weight = actual_weight
    return chargeable_weight


# 业务函数 1：计算空运运费
def cal_air_shipping_charge(volume: float, actual_weight: float) -> float:
    chargeable_weight = cal_chargeable_weight(volume, actual_weight)
    return chargeable_weight * 8.5


# 业务函数 2：计算陆运运费
def cal_land_shipping_charge(volume: float, actual_weight: float) -> float:
    chargeable_weight = cal_chargeable_weight(volume, actual_weight)
    return chargeable_weight * 3.0


# 业务函数 3：计算航运运费
def cal_sea_shipping_charge(volume: float, actual_weight: float) -> float:
    chargeable_weight = cal_chargeable_weight(volume, actual_weight)
    return chargeable_weight * 1.5


# 分别计算并输出表 2 中三件货物的运费
charge_air = cal_air_shipping_charge(120000.0, 15.0)
print(f"空运货物运费: {charge_air:.2f} 元")

charge_land = cal_land_shipping_charge(3000.0, 2.5)
print(f"陆运货物运费: {charge_land:.2f} 元")

charge_sea = cal_sea_shipping_charge(500000.0, 120.0)
print(f"航运货物运费: {charge_sea:.2f} 元")

[Q2.2] 参考解答二

工具系统（cal_chargeable_weight）接收 volume 和 actual_weight 并输出 chargeable_weight，该结果分别传入三个业务系统（cal_air_shipping_charge、cal_land_shipping_charge 和 cal_sea_shipping_charge）以计算 shipping_charge：

系统结构图（解答二）：1 个工具函数 + 3 个业务函数

[Q3] 第三题

题目描述

某零售连锁企业对新上市商品开展连续多日的试销监测，需要按天依次输出第几天、当天的预计销量和补货预警状态。

每日的补货预警判定规则如下：预计销量达到或超过 150 件时，预警状态为“红色-紧急补货”；达到 100 件但不足 150 件时，为“黄色-常规补货”；不足 100 件时，为“绿色-库存充足”。

现有一款新品，试销监测期共 3 天，第一天预计销量为 80 件，此后每天的预计销量比前一天增加 40 件。完成全部天数的监测输出后，输出一次提醒“试销监测完毕”。

  • [Q3.1] 针对上述业务场景，先给出结构化步骤描述，再编写相应的 Python 代码。

[Q3.1] 参考解答

1. 结构化步骤描述

text 
# 定义工具函数，根据给定的预计销量返回补货预警状态：
#     如果预计销量不少于 150 件：
#         返回 "红色-紧急补货"
#     否则如果预计销量不少于 100 件：
#         返回 "黄色-常规补货"
#     否则：
#         返回 "绿色-库存充足"
#
# 设置试销监测总天数为 3 天，
# 第一天预计销量为 80 件，
# 每日预计销量增量为 40 件
#
# 从第 1 天到第 3 天，逐天执行：
#     计算当天的预计销量
#     调用工具函数，获取当天预计销量对应的补货预警状态
#     输出当前是第几天、当天的预计销量和补货预警状态
#
# 全部天数处理完毕后，输出一次 "试销监测完毕"

2. Python 代码

python 
# 工具函数：根据给定的预计销量返回补货预警状态
def get_alert_status(expected_sales: int) -> str:
    if expected_sales >= 150:
        return "红色-紧急补货"
    elif expected_sales >= 100:
        return "黄色-常规补货"
    else:
        return "绿色-库存充足"


# 初始化参数
total_days = 3
initial_sales = 80
daily_increase = 40

# 从第 1 天到第 3 天逐天循环
for day in range(1, total_days + 1):
    # 计算当天的预计销量
    expected_sales = initial_sales + (day - 1) * daily_increase

    # 调用工具函数获取补货预警状态
    alert_status = get_alert_status(expected_sales)

    # 输出第几天、预计销量和预警状态
    print(f"第 {day} 天: 预计销量 = {expected_sales} 件, 预警状态 = {alert_status}")

# 循环结束后输出一次完成提醒
print("试销监测完毕")