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

Question

我有一个大的DataFrame(百万+)记录,我用来存储我的数据核心(如数据库),然后我有一个较小的DataFrame(1到2000)记录,我正在为每个记录合并一些列我的程序中的时间步长可以是几千个时间步.这两个DataFrame都由id列以相同的方式编制索引.

我正在使用的代码是:

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

其中core_cols是我正在处理的大约10个字段的列表,new_ids是来自小型DataFrame的ID.这段代码工作正常,但它是我的代码中最慢的部分,我的三个级别.我只是想知道它们是否是将两个DataFrame的数据合并在一起的更快的方法.

我尝试每次使用合并函数合并数据,但是过程变得很长,这就是我创建一个更大的DataFrame,我更新以提高速度.

Answer 1

使用.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]

这是另一种选择.它可能适合您的数据模式,也可能不适合您.如果更新(你的小框架)几乎是独立的,这将起作用(如果你没有更新大框架,然后选择一个新的子框架,然后更新等等 - 如果这是你的模式,那么使用.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]

这种模式的优点在于它很容易扩展到使用实际的数据库(或更好的HDFStore数据库),实际存储'数据库',然后根据需要创建/更新子帧,然后在完成时写入新商店.

我一直使用这种模式,但实际上是使用Panels.

• 对数据的子集执行计算并将每个写入单独的文件
• 然后在最后将它们全部读入并连接(在内存中),并写出一个巨大的新文件.concat步骤可以在内存中一次完成,或者如果真的是一个大任务,则可以迭代完成.

我能够使用多进程来执行我的计算并将每个单独的Pan​​el写成一个单独的文件,因为它们都是完全独立的.唯一的依赖部分是concat.

这基本上是一个map-reduce模式.