博客围绕冰箱生产计划，介绍了正常、加班、外协、库存等成本项目及相关假设。利用Python编写算法，依据需求预测、成本和生产能力数据，通过图表法制定生产计划，计算各季度生产任务分配和总成本，并给出代码实现及验证过程。
根据以下文本和表格，编写python代码，通过表4-6, 4-7，4-8得出4-9 图表法计算结果，用excel表格表示
一般考虑的成本项目
正常成本。指在正常稳定的生产状况下单位产品的生产成本，主要包括直接材料、直接人工和制造费用。
加班成本。随加班时间和生产率增加而呈现指数曲线状急剧上升。
外协成本。指由自制改为外协时，需要多支出的外协加工费和外协管理费等。对于短期的临时外协加工，其加工费可能大大高于本企业的正常生产成本。
库存成本。包括订货成本和保存成本。订货成本随批量的增加而减少，而保存成本随批量增加而增加。
一些假设
计划期内正常生产能力、加班生产能力以及外协量均有一定限制；
计划期的预测需求量是已知的；
全部成本都与产量呈线性关系。
(1) 将总生产能力列的生产能力数字放到“未用生产能力”一列。
(2) 在第1列（即第一时段）寻找成本最低的单元。
(3) 尽可能将生产任务分配到该时段，但不得超过该时段所在行的未使用生产能力的限制。
(4) 在该行的未使用生产能力中减掉所占用的部分，结果为余下的未使用生产能力（注意剩余的未使用生产能力绝不可能是负数，如果是负数，说明在该生产能力的约束条件下无可行解，必须增加生产能力）。如果该列仍然有需求尚未满足，重复步骤(2)-(4)，直至需求全部满足。
(5) 在其后的各时段重复步骤(2)-(4)，注意在完成一列后再继续下一列（不要同时考虑几列）。
某冰箱生产厂家，生产某品牌冰箱的需求预测，有关成本和生产能力数据如表4-6, 4-7，4-8所示。期初库存为400台，所期望的期末库存为300台。请用图表法制定生产计划。按照该厂的经营方针，不允许任务拖期和库存缺货。
表4-6需求预测
| 季度 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 需求/台 | 1600 | 2400 | 3000 | 1500 |
表4-7 成本数据 单位：元
| 单位产品的正常生产成本 | 单位产品的加班生产成本 | 单位产品外协成本 | 单位产品库存成本 |
|---|---|---|---|
| 80 | 130 | 140 | 4元/季度 |
表4-8 生产能力数据 单位：台
| 季度 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 正常生产 | 1600 | 2000 | 2100 | 1800 |
| 加班生产 | 250 | 250 | 250 | 250 |
| 外协 | 500 | 500 | 500 | 500 |
表4-9 图表法计算结果
图表csv文件表格文本如下：
单位计划期,期初库存,0,4,8,12,未用生产能力,总生产能力
,,400,,,,,
1,正常生产,80,84,,,,
,,1200,400,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
2,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
3,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
4,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
需求,,,,,,,
完成后csv文件
单位计划期,期初库存,0,4,8,12,未用生产能力,总生产能力
,,400,,,,,
1,正常生产,80,84,88,92,0,1600
,,1200,400,,,,
,加班生产,130,134,138,142,0,250
,,,,250,,,
,外协,140,144,148,152,500,500
,,,,,,,
2,正常生产,×,80,84,88,0,2000
,,,2000,,,,
,加班生产,×,130,134,138,0,250
,,,,250,,,
,外协,×,140,144,148,500,500
,,,,,,,
3,正常生产,×,×,80,84,0,2100
,,,,2100,,,
,加班生产,×,×,130,134,0,250
,,,,250,,,
,外协,×,×,140,144,250,500
,,,,150,,,
4,正常生产,×,×,×,80,0,1800
,,,,,1800,,
,加班生产,×,×,×,130,250,250
,,,,,,,
,外协,×,×,×,140,500,500
,,,,,,,
需求,,1600,2400,3000,1800,2000,10900
表4-10 冰箱生产计划
| 季度 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 正常生产 | 1600 | 2000 | 2100 | 1800 |
| 加班生产 | 250 | 250 | 250 | |
| 外协 | 150 | |||
| 调节库存 | 650 | 500 | 0 | 300 |
根据表，该计划的总成本是各单元生产任务乘以单元单位成本之和，即：
第1季度： 1200×80+400×84+250×138=164100
第2季度：2000×80+250×134=193500
第3季度：2100×80+250×130+150×140=221500
第4季度：1800×80=144000
总成本为723100元
表格输出
import pandas as pd
# 给出的文本数据
data = [
['单位计划期', '期初库存', '0', '4', '8', '12', '未用生产能力', '总生产能力'],
['', '', '400', '', '', '', '', ''],
['1', '正常生产', '80', '84', '', '', '', ''],
['', '', '1200', '400', '', '', '', ''],
['', '加班生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '外协', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['2', '正常生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '加班生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '外协', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['3', '正常生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '加班生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '外协', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['4', '正常生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '加班生产', '', '', '', '', '', ''],
['', '', '', '', '', '', '', ''],
['', '外协', '', '', '',]]
# 创建DataFrame
df = pd.DataFrame(data)
# 将DataFrame写入Excel文件
output_file = "plan_text.xlsx"
df.to_excel(output_file, index=False, header=False)
print("转换完成，Excel文件名为:", output_file)
编写算法
根据以下文本和表格，利用python编写算法，通过表4-6, 4-7，4-8的数据得出4-9 图表法计算结果，用csv表示，给出了表4-9的表格csv文本（框架，未填充数据）和正确的计算结果（csv格式），请输出csv文件并与正确的计算结果相比较，验证计算结果：
一般考虑的成本项目
正常成本。指在正常稳定的生产状况下单位产品的生产成本，主要包括直接材料、直接人工和制造费用。
加班成本。随加班时间和生产率增加而呈现指数曲线状急剧上升。
外协成本。指由自制改为外协时，需要多支出的外协加工费和外协管理费等。对于短期的临时外协加工，其加工费可能大大高于本企业的正常生产成本。
库存成本。包括订货成本和保存成本。订货成本随批量的增加而减少，而保存成本随批量增加而增加。
一些假设
计划期内正常生产能力、加班生产能力以及外协量均有一定限制；
计划期的预测需求量是已知的；
全部成本都与产量呈线性关系。
(1) 将总生产能力列的生产能力数字放到“未用生产能力”一列。
(2) 在第1列（即第一时段）寻找成本最低的单元。
(3) 尽可能将生产任务分配到该时段，但不得超过该时段所在行的未使用生产能力的限制。
(4) 在该行的未使用生产能力中减掉所占用的部分，结果为余下的未使用生产能力（注意剩余的未使用生产能力绝不可能是负数，如果是负数，说明在该生产能力的约束条件下无可行解，必须增加生产能力）。如果该列仍然有需求尚未满足，重复步骤(2)-(4)，直至需求全部满足。
(5) 在其后的各时段重复步骤(2)-(4)，注意在完成一列后再继续下一列（不要同时考虑几列）。
某冰箱生产厂家，生产某品牌冰箱的需求预测，有关成本和生产能力数据如表4-6, 4-7，4-8所示。期初库存为400台，所期望的期末库存为300台。请用图表法制定生产计划。按照该厂的经营方针，不允许任务拖期和库存缺货。
表4-6需求预测
| 季度 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 需求/台 | 1600 | 2400 | 3000 | 1500 |
表4-7 成本数据 单位：元
| 单位产品的正常生产成本 | 单位产品的加班生产成本 | 单位产品外协成本 | 单位产品库存成本 |
|---|---|---|---|
| 80 | 130 | 140 | 4元/季度 |
表4-8 生产能力数据 单位：台
| 季度 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 正常生产 | 1600 | 2000 | 2100 | 1800 |
| 加班生产 | 250 | 250 | 250 | 250 |
| 外协 | 500 | 500 | 500 | 500 |
表4-9 图表法计算结果
表4-9的csv文件表格文本如下：
单位计划期,期初库存,1,2,3,4,未用生产能力,总生产能力
,,400,,,,,
1,正常生产,80,84,,,,
,,1200,400,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
2,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
3,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
4,正常生产,,,,,,
,,,,,,,
,加班生产,,,,,,
,,,,,,,
,外协,,,,,,
,,,,,,,
需求,,,,,,,
表4-9正确输出如下（csv文件）：
单位计划期,期初库存,1,2,3,4,未用生产能力,总生产能力
,,400,,,,,
1,正常生产,80,84,88,92,0,1600
,,1200,400,,,,
,加班生产,130,134,138,142,0,250
,,,,250,,,
,外协,140,144,148,152,500,500
,,,,,,,
2,正常生产,×,80,84,88,0,2000
,,,2000,,,,
,加班生产,×,130,134,138,0,250
,,,,250,,,
,外协,×,140,144,148,500,500
,,,,,,,
3,正常生产,×,×,80,84,0,2100
,,,,2100,,,
,加班生产,×,×,130,134,0,250
,,,,250,,,
,外协,×,×,140,144,250,500
,,,,150,,,
4,正常生产,×,×,×,80,0,1800
,,,,,1800,,
,加班生产,×,×,×,130,250,250
,,,,,,,
,外协,×,×,×,140,500,500
,,,,,,,
需求,,1600,2400,3000,1800,2000,10900
算法描述如下：
第一季度，需求1600，期初库存400，本季度总需要生产1600-400=1200台，
检查列“1”，其中正常生产成本为80，成本低于加班生产成本130和外协成本140，故优先选择正常生产。
第一季度正常生产的总生产能力为1600，大于生产需求1200，故将第一季度1200台的生产任务全部分给“正常生产”，此时，第一季度“正常生产”的生产能力还剩1600-1200=400台。
所以，第一季度需求1200的任务，来自第一季度“正常生产”的1200台。
第二季度，需求2400，本季度总需要生产2400台。
检查列“2”，其中第二季度正常生产成本为80，最低，故优先选择第二季度的正常生产。
第二季度正常生产的总生产能力为2000，小于生产需求2400，故将第二季度2000台的生产任务全部分给“正常生产”，此时第二季度的生产需求还剩400台。
此时第二季度的“正常生产”生产能力2000台已经全部占用，故考虑成本第二低的第一季度正常生产，其生产成本为（当期季度成本80+库存成本4=84），低于其他生产方式的成本，在完成第一季度的需求后，第一季度“正常生产”还剩400台的生产能力，刚好满足第二季度剩下的生产需求，故将第二季度剩下的400台生产任务全部分给第一季度的“正常生产”，此时，第一季度“正常生产”的生产能力全部用完，第二季度“正常生产”的生产能力也全部用完。
第二季度的需求2400的任务来自两个部分，第一个部分是来自第一季度“正常生产”的400台，第二个部分是来自第二季度“正常生产”的2000台。
第三季度，需求3000，本季度总需要生产3000台。
检查列“3”，其中第三季度正常生产成本为80，最低，故优先选择第三季度的正常生产。
第三季度正常生产的总生产能力为2100，小于生产需求3000，故将第三季度2100台的生产任务全部分给“正常生产”，此时第二季度的生产需求还剩900台。
此时第三季度的“正常生产”生产能力2100台已经全部占用，故考虑成本第二低的第三季度加班生产，其生产成本为（当期季度成本130+库存成本0=130），低于其他生产方式的成本，其生产能力为250,低于第三季度的剩余需求，故将第三季度剩下需求中的250台生产任务全部分给第三季度加班生产，此时第三季度需求还剩900-250=650台。
此时考虑成本第三低的第二季度加班生产，其生产成本为（当期季度成本130+库存成本4=134），低于其他生产方式的成本，其生产能力为250,低于第三季度的剩余需求，故将第三季度剩下需求中的250台生产任务全部分给第二季度加班生产，此时第三季度需求还剩650-250=400台。
此时考虑成本第四低的第一季度加班生产，其生产成本为（当期季度成本130+2x（库存成本4）=138），低于其他生产方式的成本，其生产能力为250,低于第三季度的剩余需求，故将第三季度剩下需求中的250台生产任务全部分给第一季度加班生产，此时第三季度需求还剩400-250=150台。
此时考虑成本第五低的第三季度外协，其生产成本为（当期季度成本140+（库存成本0）=140），低于其他生产方式的成本，其生产能力为500,高于第三季度的剩余需求，故将第三季度剩下需求中的150台生产任务全部分给第三季度外协，此时第三季度需求还剩150-150=0台。此时需求完全满足。此时，第一季度、第二季度、第二季度的“加班生产”的生产能力全部用完。第三季度的外协生产能力还剩500-150=350台。
第三季度的需求2400台来自5 个部分，分别是第一季度加班生产250台，第二季度加班生产250台，第三季度加班生产250台，第三季度正常生产2100台，第三季度外协150台。
第四季度，需求1800，期初库存0，本季度总需要生产1800台。
检查列“4”，其中第四季度正常生产成本为80，最低，故优先选择第四季度的正常生产。
第四季度正常生产的总生产能力为1800，刚好等于生产需求1800，故将第四季度1800台的生产任务全部分给“正常生产”，此时第四季度的生产需求还剩1800-1800=0台。第四季度生产需求完全满足。
第四季度的需求1800台来自1个部分，全部来自第四季度的“正常生产”1800台。
做算法时应当按照以下顺序：1.计算本季度生产需求2.查找仍有生产能力的生产方式，包括上一季度的生产方式，将仍有生产能力余量的生产方式纳入本季度生产方式的考虑范围中。3.从考虑范围中选择成本最低的方式，根据该方式的剩余总生产能力分配生产量，若分配后，该生产方式所生产数量仍未达到本季度需求，则考虑成本第二低的，以此类推，直到本季度需求全部被满足为止。4.计算出每一种生产方式剩余的生产能力，并检验本期每一种生产方式所生产数量之和是否等于本季度生产需求，若等于，进入下一个季度
代码
数据输入
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1600, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
计算成本
import pandas as pd
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 计算每种生产方式在各个季度的成本
for i in range(4):
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
unit_cost = cost + 4 * i # 单位成本随季度增加
costs[method].append(unit_cost)
# 输出每种生产方式在各个季度的成本
for method in costs:
print(f"{method} 的单位成本:")
for i, cost in enumerate(costs[method], 1):
print(f" 季度 {i}: {cost}")
输入代码综合
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 计算每种生产方式在各个季度的成本
for i in range(4):
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
unit_cost = cost + 4 * i # 单位成本随季度增加
costs[method].append(unit_cost)
# 输出每种生产方式在各个季度的成本
for method in costs:
print(f"{method} 的单位成本:")
for i, cost in enumerate(costs[method], 1):
print(f" 季度 {i}: {cost}")
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括上一季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
capacity = capacity_data[method][quarter - 1]
if capacity > 0:
available_methods.append((method, cost, capacity))
# 按成本从低到高排序
available_methods.sort(key=lambda x: x[1])
# 分配生产量
for method, cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f" {method} 生产 {production_quantity} 台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity = {method: capacity - sum(production["生产数量"][-3:]) if quarter > 1 else capacity for method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity.items():
print(f" {method}: {capacity}")
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
第一季度计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括上一季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
capacity = capacity_data[method][quarter - 1]
if capacity > 0:
available_methods.append((method, cost, capacity))
# 按成本从低到高排序
available_methods.sort(key=lambda x: x[1])
# 分配生产量
for method, cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f" {method} 生产 {production_quantity} 台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity = {method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity.items():
print(f" {method}: {capacity}")
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
剩余生产能力及成本计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储上一季度末剩余生产能力
last_quarter_remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算上一季度末剩余生产能力及成本
if quarter > 1:
print(f"上一季度末剩余生产能力及成本：")
for method, capacity in last_quarter_remaining_capacity.items():
cost = costs[method][-1] + 4 # 上一季度末成本统一增加4
print(f" {method}: 剩余生产能力 {capacity}，成本 {cost}")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括上一季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
capacity = capacity_df[method][quarter - 1]
if capacity > 0:
available_methods.append((method, cost, capacity))
# 按成本从低到高排序
available_methods.sort(key=lambda x: x[1])
# 分配生产量
for method, cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity = {method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
last_quarter_remaining_capacity = remaining_capacity.copy()
print("剩余生产能力:")
for method, capacity in remaining_capacity.items():
print(f" {method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
cost = cost_df.loc[cost_df["成本项目"] == method, "成本"].values[0]
costs[method].append(cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
第二季度数值计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储上一季度末剩余生产能力
last_quarter_remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算上一季度末剩余生产能力及成本
if quarter > 1:
print(f"上一季度末剩余生产能力及成本：")
for method, capacity in last_quarter_remaining_capacity.items():
cost = costs[method][-1] + 4 # 上一季度末成本统一增加4
print(f" {method}: 剩余生产能力 {capacity}，成本 {cost}")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括上一季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
capacity = capacity_df[method][quarter - 1]
if capacity > 0:
available_methods.append((method, cost, capacity))
# 如果不是第一季度，考虑上一季度末剩余生产能力的生产方式
if quarter > 1:
for method, capacity in last_quarter_remaining_capacity.items():
cost = costs[method][-1] + 4 # 上一季度末成本统一增加4
available_methods.append((method, cost, capacity))
# 按成本从低到高排序
available_methods.sort(key=lambda x: x[1])
# 输出成本排序信息
cost_info = " < ".join([f"{method}{cost}" for method, cost, _ in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for method, cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity = {method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
last_quarter_remaining_capacity = remaining_capacity.copy()
print("剩余生产能力:")
for method, capacity in remaining_capacity.items():
print(f" {method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
cost = cost_df.loc[cost_df["成本项目"] == method, "成本"].values[0]
costs[method].append(cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
名称命名正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算之前所有季度的剩余生产能力及成本
for q in range(1, quarter):
print(f"第{q}季度末剩余生产能力及成本：")
for method, capacity in remaining_capacity[q].items():
cost = costs[method][-1] + 4 # 上一季度末成本统一增加4
print(f" 第{q}季度{method}，用于第{quarter}季度的成本为{cost}")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
cost = row["成本"]
capacity = capacity_df[method][quarter - 1] + sum(remaining_capacity.get(q, {}).get(method, 0) for q in range(1, quarter))
if capacity > 0:
available_methods.append((method, cost, capacity))
# 按成本从低到高排序
available_methods.sort(key=lambda x: x[1])
# 输出成本排序信息
cost_info = " < ".join([f"第{quarter}季度{method}，用于第{quarter}季度的成本{cost}" for method, cost, _ in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for method, cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" {method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
cost = cost_df.loc[cost_df["成本项目"] == method, "成本"].values[0]
costs[method].append(cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
成本计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算之前所有季度的剩余生产能力及成本
for q in range(1, quarter):
print(f"第{q}季度末剩余生产能力及成本：")
for method, capacity in remaining_capacity[q].items():
cost = costs[method][-1] + abs(quarter - q) * 4 # 成本计算公式
print(f" 第{q}季度{method}，用于第{quarter}季度的成本为{cost}")
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] + sum(remaining_capacity.get(q, {}).get(method, 0) for q in range(1, quarter))
if capacity > 0:
available_methods.append((method, base_cost, capacity))
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[1] + abs(quarter - 1) * 4)
# 输出成本排序信息
cost_info = " < ".join([f"第{quarter}季度{method}，用于第{quarter}季度的成本{cost}" for method, cost, _ in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for method, base_cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" {method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
名称及成本正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算之前所有季度的剩余生产能力及成本
for q in range(1, quarter):
print(f"第{q}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{q}季度末剩余生产能力：")
for method, capacity in remaining_capacity[q].items():
if capacity != 0:
cost = costs[method][-1] + abs(quarter - q) * 4 # 上一季度末成本统一增加4
print(f" 第{q}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((method, cost, capacity))
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
available_methods = []
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] + sum(
remaining_capacity.get(q, {}).get(method, 0) for q in range(1, quarter))
if capacity > 0:
available_methods.append((method, base_cost, capacity))
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[1] + abs(quarter - 1) * 4)
# 输出成本排序信息
cost_info = " < ".join([f"第{quarter}季度{method}，用于第{quarter}季度的成本{cost}" for method, cost, _ in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for method, base_cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {
method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
季度命名错误
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [], "加班生产": [], "外协": []}
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for q in range(1, quarter):
print(f"第{q}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{q}季度末剩余生产能力：")
for method, capacity in remaining_capacity[q].items():
if capacity != 0:
cost = costs[method][-1] + abs(quarter - q) * 4 # 上一季度末成本统一增加4
print(f" 第{q}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((method, cost, capacity))
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] + sum(
remaining_capacity.get(q, {}).get(method, 0) for q in range(1, quarter))
if capacity > 0:
available_methods.append((method, base_cost, capacity))
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[1] + abs(quarter - 1) * 4)
# 输出成本排序信息
cost_info = " < ".join([f"第{quarter}季度{method}，用于第{quarter}季度的成本{cost}" for method, cost, _ in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for method, base_cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity)
production["季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{quarter}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {
method: capacity - production_quantity if method == production["生产方式"][-1] else capacity for
method, _, capacity in available_methods}
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
print("生产情况：")
print(production_df)
季度命名正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter + 1): # 修改这里以包含两个季度变量
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] + sum(
remaining_capacity.get(jidu, {}).get(method, 0) for jidu in range(1, quarter + 1)) # 修改这里以包含两个季度变量
if capacity > 0:
available_methods.append((jidu, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] + abs(quarter - x[0]) * 4) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= 0:
break
production_quantity = min(demand, capacity, remaining_capacity.get(quarter, {}).get(method, capacity)) # 考虑剩余生产能力
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
demand -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if demand != 0:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter): # 修改这里，跳过当前季度的计算
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] + sum(
remaining_capacity.get(jidu, {}).get(method, 0) for jidu in range(1, quarter)) # 修改这里以包含两个季度变量
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] + abs(quarter - x[0]) * 4) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
第1，2季度计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
if method == "正常生产": # 仅考虑本季度正常生产的总生产力
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter): # 修改这里，跳过当前季度的计算
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] # 仅考虑本季度的生产能力
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] + abs(quarter - x[0]) * 4) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
基本正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
if method == "正常生产": # 仅考虑本季度正常生产的总生产力
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter + 1): # 修改这里，确保考虑到之前所有季度的生产情况
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] # 仅考虑本季度的生产能力
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] + abs(quarter - x[0]) * 4) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 更新之前季度的剩余生产能力
for j in range(jidu, quarter): # 更新之前季度的剩余生产能力
remaining_capacity[j][method] -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
数值完全正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
if method == "正常生产": # 仅考虑本季度正常生产的总生产力
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter + 1): # 修改这里，确保考虑到之前所有季度的生产情况
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] # 仅考虑本季度的生产能力
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] ) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 更新之前季度的剩余生产能力
for j in range(jidu, quarter): # 更新之前季度的剩余生产能力
remaining_capacity[j][method] -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
修改以下代码，使得输出为表格生产计划，包括每个季度对每个季度的生产方式及成本，若一个季度的时间顺序在另一个顺序之后（如第2季度和第1季度）,则第2季度对第1季度生产标注为“X”
最终代码
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
if method == "正常生产": # 仅考虑本季度正常生产的总生产力
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter + 1): # 修改这里，确保考虑到之前所有季度的生产情况
#print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
#print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0: # 添加条件以确保剩余生产能力不为负值
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
#print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity)) # 添加生产季度变量
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] # 仅考虑本季度的生产能力
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3] ) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
#print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 更新之前季度的剩余生产能力
for j in range(jidu, quarter): # 更新之前季度的剩余生产能力
remaining_capacity[j][method] -= production_quantity
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity) # 调整剩余生产能力的记录，并确保不为负值
#print("剩余生产能力:")
#for method, capacity in remaining_capacity[quarter].items():
# print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
简化代码
import pandas as pd
demand_data = {"季度": [1, 2, 3, 4], "需求/台": [1200, 2400, 3000, 1800]}
demand_df = pd.DataFrame(demand_data)
cost_data = {"成本项目": ["正常生产", "加班生产", "外协"], "基础成本": [80, 130, 140]}
cost_df = pd.DataFrame(cost_data)
capacity_data = {"季度": [1, 2, 3, 4], "正常生产": [1600, 2000, 2100, 1800], "加班生产": [250, 250, 250, 250], "外协": [500, 500, 500, 500]}
capacity_df = pd.DataFrame(capacity_data)
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]}
remaining_capacity = {}
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
available_methods = []
for jidu in range(1, quarter + 1):
for prev_quarter in range(1, jidu + 1):
for method, capacity in remaining_capacity.get(prev_quarter, {}).items():
if capacity > 0:
cost = costs[method][-1] + abs(quarter - prev_quarter) * 4
available_methods.append((prev_quarter, quarter, method, cost, capacity))
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1]
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity))
available_methods.sort(key=lambda x: x[3])
distributed_demand = 0
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand:
break
max_production = min(demand - distributed_demand, capacity)
production_quantity = max_production
production["生产季度"].append(jidu)
production["当期季度"].append(quarter)
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
distributed_demand += max_production
for j in range(jidu, quarter):
remaining_capacity[j][method] -= production_quantity
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_capacity[quarter][method] = max(0, capacity - production_quantity if method == production["生产方式"][-1] else capacity)
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
print()
production_df = pd.DataFrame(production)
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
生产能力计算正确
import pandas as pd
# 需求预测表格
demand_data = {
"季度": [1, 2, 3, 4],
"需求/台": [1200, 2400, 3000, 1800]
}
demand_df = pd.DataFrame(demand_data)
# 成本数据表格
cost_data = {
"成本项目": ["正常生产", "加班生产", "外协"],
"基础成本": [80, 130, 140]
}
cost_df = pd.DataFrame(cost_data)
# 生产能力数据表格
capacity_data = {
"季度": [1, 2, 3, 4],
"正常生产": [1600, 2000, 2100, 1800],
"加班生产": [250, 250, 250, 250],
"外协": [500, 500, 500, 500]
}
capacity_df = pd.DataFrame(capacity_data)
# 存储每季度生产情况
production = {"生产季度": [], "当期季度": [], "生产方式": [], "生产数量": []}
# 存储每种生产方式的成本
costs = {"正常生产": [0], "加班生产": [0], "外协": [0]} # 添加初始值
# 存储每季度末剩余生产能力
remaining_capacity = {}
# 执行生产计划
for quarter, demand in zip(demand_df["季度"], demand_df["需求/台"]):
print(f"第{quarter}季度生产计划：")
# 输出本季度各种生产方式的总生产力
print(f"第{quarter}季度各种生产方式的总生产力：")
for method, capacity in capacity_df.iloc[quarter - 1].items():
if method == "正常生产": # 仅考虑本季度正常生产的总生产力
print(f" 第{quarter}季度{method}: {capacity}")
# 计算之前所有季度的剩余生产能力及成本
available_methods = []
for jidu in range(1, quarter + 1):
print(f"第{jidu}季度末已结算剩余生产能力及成本：")
# 打印之前季度所有剩余生产能力数值
print(f" 第{jidu}季度末剩余生产能力：")
for method, capacity in remaining_capacity.get(jidu, {}).items():
if capacity > 0:
cost = costs[method][-1] + abs(quarter - jidu) * 4 # 上一季度末成本统一增加4
print(f" 第{jidu}季度{method}，用于第{quarter}季度的剩余生产能力{capacity}，成本为{cost}")
# 将剩余生产能力不为0的生产方式计算其成本，并纳入本季度的成本排序中
available_methods.append((jidu, quarter, method, cost, capacity))
# 计算本季度生产需求
print(f"本季度需求: {demand}")
# 查找仍有生产能力的生产方式，包括之前所有季度的生产方式
for index, row in cost_df.iterrows():
method = row["成本项目"]
base_cost = row["基础成本"]
capacity = capacity_df[method][quarter - 1] # 仅考虑本季度的生产能力
if capacity > 0:
available_methods.append((quarter, quarter, method, base_cost, capacity)) # 添加生产季度变量
# 按调整后的成本从低到高排序
available_methods.sort(key=lambda x: x[3]) # 调整排序的键
# 输出成本排序信息
cost_info = " < ".join([f"第{method[0]}季度{method[2]}，用于第{method[1]}季度的成本{method[3]}" for method in available_methods])
print(f"成本排序：{cost_info}")
# 分配生产量
distributed_demand = 0 # 已分配的需求量
for jidu, quarter, method, base_cost, capacity in available_methods:
if demand <= distributed_demand: # 如果需求已满足，则跳出循环
break
max_production = min(demand - distributed_demand, capacity) # 最大生产量为剩余需求量和生产能力中的较小值
production_quantity = max_production
production["生产季度"].append(jidu) # 添加生产季度
production["当期季度"].append(quarter) # 添加当期季度
production["生产方式"].append(method)
production["生产数量"].append(production_quantity)
print(f"第{jidu}季度{method}，用于第{quarter}季度的生产量为{production_quantity}台")
distributed_demand += max_production
# 更新之前季度的剩余生产能力
for j in range(jidu, quarter):
remaining_production_capacity = remaining_capacity.get(j, {}).get(method, 0) # 考虑之前季度的剩余生产能力
# 对于正常生产，还需要考虑本季度的正常生产消耗的生产力
if method == "正常生产":
remaining_production_capacity -= demand_data["需求/台"][j - 1]
if remaining_production_capacity > 0:
remaining_production_capacity -= production_quantity # 减去本季度生产的数量
remaining_capacity[j][method] = max(0, remaining_production_capacity) # 调整剩余生产能力的记录，并确保不为负值
# 计算出每一种生产方式剩余的生产能力
remaining_capacity[quarter] = {}
for jidu, quarter, method, base_cost, capacity in available_methods:
remaining_production_capacity = max(0, capacity - production_quantity if method == "正常生产" else capacity)
# 对于正常生产，还需要考虑本季度的正常生产消耗的生产力
if method == "正常生产":
remaining_production_capacity -= demand_data["需求/台"][quarter - 1]
remaining_capacity[quarter][method] = max(0, remaining_production_capacity) # 调整剩余生产能力的记录，并确保不为负值
print("剩余生产能力:")
for method, capacity in remaining_capacity[quarter].items():
print(f" 第{quarter}季度{method}: {capacity}")
# 计算本季度每种生产方式的成本并存储
for method in costs:
base_cost = cost_df.loc[cost_df["成本项目"] == method, "基础成本"].values[0]
costs[method].append(base_cost)
# 检验本期每一种生产方式所生产数量之和是否等于本季度生产需求
if distributed_demand != demand:
print("Error: 生产数量与需求不匹配")
if distributed_demand > demand:
print("Error: 分配的生产数量超出了总需求量")
print()
# 输出生产情况
production_df = pd.DataFrame(production)
# 根据生产季度和当期季度排序生产情况
production_df = production_df.sort_values(by=["生产季度", "当期季度"])
print("生产情况：")
print(production_df)
扫一扫
1840
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
