如何迭代扩展pd.DataFrame，避免列表过度分配优化内存效率？

你常用的这段收集DataFrame再合并的代码：

df_collection = []
for iteration in iterations:
   df_this_iteration = computational_step(*many_other_iteration_specific_params...)
   df_collection.append(df_this_iteration)
df_collection = pd.concat(df_collection,axis=0)

当iterations规模或单个df_this_iteration体积较大时，列表的动态扩容机制会带来显著的内存开销——正如Micha Gorelick与Ian Ozsvald所著《High Performance Python》中提到的：

当首次对一个长度为N的列表执行append操作时，Python必须创建一个能容纳原有N个元素加新增元素的新列表。但实际上Python会分配能容纳M个元素的空间（M>N），为后续的append操作预留额外空间。接着把旧列表的数据复制到新列表，旧列表被销毁。这种设计的思路是，一次append操作往往意味着后续会有更多同类操作，通过预留额外空间可以减少内存分配的次数，进而减少必要的内存复制次数。这一点非常重要，因为内存复制的开销很高，尤其是当列表规模开始增长时。

当列表中存储的是体积较大的DataFrame时，每次扩容的内存复制开销会被放大，导致内存占用过高、运行效率低下。以下是几种针对性的改进方案：

1. 预分配列表空间 #

如果能提前获取iterations的长度，直接初始化指定长度的列表，避免动态扩容带来的内存复制：

# 先获取总迭代次数
total_iter = len(iterations)
# 预分配列表空间
df_collection = [None] * total_iter

for idx, iteration in enumerate(iterations):
    df_this_iteration = computational_step(*many_other_iteration_specific_params...)
    df_collection[idx] = df_this_iteration

final_df = pd.concat(df_collection, axis=0)

列表初始化时就分配了足够容纳所有元素的空间，后续只需替换对应位置的元素，完全避免扩容和内存复制操作。

2. 直接收集底层数据，避免存储小DataFrame #

如果每个df_this_iteration的列结构固定，可以直接收集各列的底层numpy数组，最后一次性构造大DataFrame，减少小DataFrame的元数据开销：

# 假设每个结果DataFrame包含col1、col2、col3三列
col1_data = []
col2_data = []
col3_data = []

for iteration in iterations:
    df = computational_step(*many_other_iteration_specific_params...)
    # 直接扩展底层数组
    col1_data.extend(df['col1'].values)
    col2_data.extend(df['col2'].values)
    col3_data.extend(df['col3'].values)

# 一次性生成最终DataFrame
final_df = pd.DataFrame({
    'col1': col1_data,
    'col2': col2_data,
    'col3': col3_data
})

这种方式跳过了存储多个小DataFrame的额外内存开销，直接操作最紧凑的数组形式，内存利用率大幅提升。

3. 分块合并，降低内存峰值 #

当迭代次数极多时，一次性存储所有小DataFrame会占用大量内存，可以分块合并并及时释放临时内存：

chunk_size = 100  # 根据机器内存情况调整块大小
df_collection = []
final_df = pd.DataFrame()

for idx, iteration in enumerate(iterations):
    df_this_iteration = computational_step(*many_other_iteration_specific_params...)
    df_collection.append(df_this_iteration)
    
    # 达到块大小或迭代结束时，合并当前块并清空临时列表
    if (idx + 1) % chunk_size == 0 or (idx + 1) == len(iterations):
        temp_df = pd.concat(df_collection, axis=0)
        final_df = pd.concat([final_df, temp_df], axis=0)
        df_collection = []  # 清空列表，释放临时内存

# 重置索引
final_df = final_df.reset_index(drop=True)

每次仅保留一个块的小DataFrame，内存峰值会远低于一次性存储所有结果的方式。

4. 向量化计算（最优方案，需逻辑支持） #

如果computational_step的计算逻辑可以改造成向量化形式，直接对所有迭代参数批量处理，完全避免循环和列表收集：

# 先整理所有迭代所需的参数为批量形式
all_params = [get_iteration_params(iter) for iter in iterations]
# 用向量化函数直接生成最终大DataFrame
final_df = vectorized_computational_step(all_params)

这种方式利用Pandas/Numpy的向量化运算优势，彻底消除循环和列表扩容的开销，是效率最高的方案，但需要根据具体计算逻辑调整实现。

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