如何动态操作多个DataFrames：实现recs_df与cost_df批量相乘

我正在尝试动态操作一系列DataFrames。例如，我希望将多个recs_df（如下所示）与另一个cost_df进行相乘运算：

recs_df1:
         Prod      Ord1  Ord2  Ord3
    0    Toys       4      2    1
    1    Candy      3      1    5
    2    Décor      2      3    4
    
recs_df2:
         Prod      Ord1  Ord2  Ord3
    0    Toys       1     0     6
    1    Candy      4     1     5
    2    Décor      2     3     4
    
recs_df3:
         Prod      Ord1  Ord2  Ord3
    0    Toys       1     2     3
    1    Candy      0     1     0
    2    Décor      1     3     4
    
cost_df:
         Prod    Price
    0    Toys    2.00
    1    Candy   1.00
    2    Décor   3.00

期望得到3个新DataFrames，由每个recs_df与cost_df相乘得到，即：

new_df1:
0    Toys        8.00       4.00     2.00    
1    Candy       3.00       1.00     5.00
2    Décor       6.00       9.00     12.00

new_df2:     
0    Toys       2.00      0.00       12.00
1    Candy      4.00      1.00        5.00
2    Décor      6.00      9.00       12.00

new_df3:
0    Toys       2.00       4.00        6.00
1    Candy      0.00       1.00        0.00
2    Décor      3.00       9.00       12.00

我尝试过创建DataFrames列表并直接循环处理，但总是出现错误，例如：

df_list = [recs_df1, recs_df2, recs_df3]
for df in df_list:
    new_df.append(cost_df*df_list)

new_dfs  = [ ]
for j in range(3):
   for i in range(0,len(recs_df[j].index)):
          new=append((cost_df*df_list[j])
   new_dfs=pd.DataFrame(new)

希望得到建议，谢谢。

你的核心问题是未正确对齐Prod列执行元素相乘，且循环逻辑存在语法错误（比如直接用cost_df*df_list是DataFrame与列表相乘，不符合语法；append调用方式错误）。

正确处理步骤如下：

1. 将价格数据转为索引匹配的Series：把cost_df的Price列转换为以Prod为索引的Series，方便快速匹配每个产品的价格。
2. 批量处理DataFrame列表：遍历每个recs_df，将订单列（Ord1、Ord2、Ord3）与对应产品价格相乘，保留Prod列。

具体代码实现：

import pandas as pd

# 初始化示例DataFrames
recs_df1 = pd.DataFrame({
    'Prod': ['Toys', 'Candy', 'Décor'],
    'Ord1': [4, 3, 2],
    'Ord2': [2, 1, 3],
    'Ord3': [1, 5, 4]
})
recs_df2 = pd.DataFrame({
    'Prod': ['Toys', 'Candy', 'Décor'],
    'Ord1': [1, 4, 2],
    'Ord2': [0, 1, 3],
    'Ord3': [6, 5, 4]
})
recs_df3 = pd.DataFrame({
    'Prod': ['Toys', 'Candy', 'Décor'],
    'Ord1': [1, 0, 1],
    'Ord2': [2, 1, 3],
    'Ord3': [3, 0, 4]
})
cost_df = pd.DataFrame({
    'Prod': ['Toys', 'Candy', 'Décor'],
    'Price': [2.00, 1.00, 3.00]
})

# 转换为以产品名为索引的价格Series
price_series = cost_df.set_index('Prod')['Price']

# 定义单个recs_df的处理函数
def calculate_total_cost(recs_df):
    # 保留Prod列
    result_df = recs_df[['Prod']].copy()
    # 遍历所有订单列，执行相乘操作
    for col in ['Ord1', 'Ord2', 'Ord3']:
        result_df[col] = recs_df[col] * recs_df['Prod'].map(price_series)
    return result_df

# 批量处理所有recs_df
df_list = [recs_df1, recs_df2, recs_df3]
new_dfs = [calculate_total_cost(df) for df in df_list]

# 输出结果示例
print("new_df1:")
print(new_dfs[0])
print("\nnew_df2:")
print(new_dfs[1])
print("\nnew_df3:")
print(new_dfs[2])

代码说明 #

• price_series：将cost_df转换为以产品名为索引的Series，通过map方法可以快速为recs_df的每一行匹配对应产品的价格。
• calculate_total_cost函数：接收单个recs_df，复制Prod列后，对每个订单列执行数量×价格的计算，确保结果列与原数据对齐。
• 列表推导式：用[calculate_total_cost(df) for df in df_list]简洁地批量处理所有DataFrame，生成的new_dfs列表中，new_dfs[0]对应new_df1，以此类推。

这样处理后即可得到你需要的3个新DataFrames，代码逻辑清晰，避免了循环嵌套的错误。

内容的提问来源于stack exchange，提问作者user23317935