使用Pandas将列从一个DataFrame复制到另一个的最快方法？

Z时代
2024-01-10
分类：问答

我有一个大的DataFrame（一百万个）记录，用于存储数据的核心（如数据库），然后有一个较小的DataFrame（1到2000个）记录，每个记录都合并了几列我程序中的时间步长可能是几千个时间步长。通过id列以相同的方式对两个DataFrame进行索引。

我正在使用的代码是：

df_large.loc[new_ids, core_cols] = df_small.loc[new_ids, core_cols]

其中core_cols是我要处理的大约10个字段的列表，而new_id是小DataFrame中的ID。这段代码可以正常工作，但是它是我的代码中最慢的部分（三级）。我只是想知道它们是否是将两个DataFrame的数据合并在一起的更快方法。

我每次都尝试使用merge函数合并数据，但是过程花了很长时间，所以我不得不创建一个更大的DataFrame进行更新，以提高速度。

回答：

使用.loc可对齐框架进行设置本质上没有什么慢，尽管它确实会花费一些代码来涵盖很多情况，所以紧密循环可能并不理想。仅供参考，此示例与第二示例略有不同。

In [1]: import numpy as np
In [2]: import pandas as pd
In [3]: from pandas import DataFrame
In [4]: df = DataFrame(1.,index=list('abcdefghij'),columns=[0,1,2])
In [5]: df
Out[5]: 
   0  1  2
a  1  1  1
b  1  1  1
c  1  1  1
d  1  1  1
e  1  1  1
f  1  1  1
g  1  1  1
h  1  1  1
i  1  1  1
j  1  1  1
[10 rows x 3 columns]
In [6]: df2 = DataFrame(0,index=list('afg'),columns=[1,2])
In [7]: df2
Out[7]: 
   1  2
a  0  0
f  0  0
g  0  0
[3 rows x 2 columns]
In [8]: df.loc[df2.index,df2.columns] = df2
In [9]: df
Out[9]: 
   0  1  2
a  1  0  0
b  1  1  1
c  1  1  1
d  1  1  1
e  1  1  1
f  1  0  0
g  1  0  0
h  1  1  1
i  1  1  1
j  1  1  1
[10 rows x 3 columns]

这是另一种选择。它可能适合也可能不适合您的数据模式。如果更新（您的小框架）非常独立，那么它将起作用（IOW，您不更新大框架，然后选择新的子框架，然后进行更新，等等。-如果这是您的模式，则使用.loc大约对）。

代替更新大框架，而是使用大框架中的列更新小框架，例如：

In [10]: df = DataFrame(1.,index=list('abcdefghij'),columns=[0,1,2])
In [11]: df2 = DataFrame(0,index=list('afg'),columns=[1,2])
In [12]: needed_columns = df.columns-df2.columns
In [13]: df2[needed_columns] = df.reindex(index=df2.index,columns=needed_columns)
In [14]: df2
Out[14]: 
   1  2  0
a  0  0  1
f  0  0  1
g  0  0  1
[3 rows x 3 columns]
In [15]: df3 = DataFrame(0,index=list('cji'),columns=[1,2])
In [16]: needed_columns = df.columns-df3.columns
In [17]: df3[needed_columns] = df.reindex(index=df3.index,columns=needed_columns)
In [18]: df3
Out[18]: 
   1  2  0
c  0  0  1
j  0  0  1
i  0  0  1
[3 rows x 3 columns]

并在需要时将所有内容合并在一起（同时将它们保存在列表中，或者在下面查看我的评论，这些子帧可以在创建时移至外部存储，然后在此合并步骤之前回读）。

In [19]: pd.concat([ df.reindex(index=df.index-df2.index-df3.index), df2, df3]).reindex_like(df)
Out[19]: 
   0  1  2
a  1  0  0
b  1  1  1
c  1  0  0
d  1  1  1
e  1  1  1
f  1  0  0
g  1  0  0
h  1  1  1
i  1  0  0
j  1  0  0
[10 rows x 3 columns]

这种模式的优点在于，它可以轻松扩展为使用实际的db（或更好的db

HDFStore），以实际存储“数据库”，然后根据需要创建/更新子框架，然后在完成后写出到新存储中。

我一直使用这种模式，尽管实际上是使用面板。