大DataFrame多列加权求和的内存最优实现方法

我有多个超大DataFrame，在对它们进行加权求和合并时频繁遇到内存不足的情况。当前的实现方式如下：

dfA[col] = dfA[col]*wA + dfB[col]*wB + dfC[col]*wC + dfD[col]*wD

其中wA、wB等是对应DataFrame的权重。这种方法有80%的概率会触发内存不足。

我尝试过逐次累加的方式：

dfA[col] = dfA[col]*wA
dfA[col] += dfB[col]*wB
dfA[col] += dfC[col]*wC
dfA[col] += dfD[col]*wD

但针对相同的DataFrame，这种方式依然必然会出现内存不足。

请问是否应该通过遍历行并使用iloc实现？或是借助Numpy实现后再转换回DataFrame？

优化方案 #

1. 直接操作Numpy数组（最优选择） #

Pandas DataFrame的底层是Numpy数组，直接操作数组能规避Pandas的额外内存开销：

• 先将每个DataFrame的目标列转换为Numpy数组
• 原地执行加权累加，最后按需赋值回DataFrame

示例代码：

# 获取各列的Numpy数组
arrA = dfA[col].to_numpy()
arrB = dfB[col].to_numpy()
arrC = dfC[col].to_numpy()
arrD = dfD[col].to_numpy()

# 原地计算：避免生成大量临时中间对象
arrA *= wA
arrA += arrB * wB
arrA += arrC * wC
arrA += arrD * wD

# 若需保留DataFrame结构，将结果写回
dfA[col] = arrA

这种方法内存占用最低，因为所有操作都在原数组上进行，不会像Pandas Series那样生成额外的包装对象。

2. 分块处理（极端大场景） #

如果连Numpy数组都无法一次性载入内存，可按行分块处理：

• 设定合理的块大小（如10000行/块）
• 逐块读取各DataFrame的对应列，完成计算后写入结果

示例代码：

chunk_size = 10000
total_rows = len(dfA)

for i in range(0, total_rows, chunk_size):
    # 读取当前块的数组
    chunkA = dfA[col].iloc[i:i+chunk_size].to_numpy()
    chunkB = dfB[col].iloc[i:i+chunk_size].to_numpy()
    chunkC = dfC[col].iloc[i:i+chunk_size].to_numpy()
    chunkD = dfD[col].iloc[i:i+chunk_size].to_numpy()
    
    # 块内加权求和
    chunkA *= wA
    chunkA += chunkB * wB
    chunkA += chunkC * wC
    chunkA += chunkD * wD
    
    # 写回原DataFrame
    dfA[col].iloc[i:i+chunk_size] = chunkA

分块处理会牺牲部分效率，但能将内存占用控制在单块数据的大小范围内。

3. 禁止逐行iloc遍历 #

不要用iloc逐行处理，这种方式会频繁创建Pandas对象，不仅效率极低，内存优化效果也极差，完全没必要。

4. 前置数据类型优化 #

计算前先优化数据类型，从根源减少内存占用：

• 若无需高精度，将float64转为float32，内存直接减半
• 整数类型同理，如int64转int32/int16（需确保数据范围足够）

示例代码：

dfA[col] = dfA[col].astype('float32')
dfB[col] = dfB[col].astype('float32')
# 其他DataFrame列同理转换

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