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]

这是另一种选择。它可能适合您的数据模式，也可能不适合您。如果更新（你的小框架）几乎是独立的，这将起作用（如果你没有更新大框架，然后选择一个新的子框架，然后更新等等 - 如果这是你的模式，那么使用{{ 1}}是关于正确的。）

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

.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]），实际存储'数据库'，然后根据需要创建/更新子帧，然后完成后写到新店。

我一直使用这种模式，但实际上是Panels。

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

我能够使用多进程执行计算并将每个Panel单独写入一个文件，因为它们都是完全独立的。唯一的依赖部分是concat。

这实际上是一种map-reduce模式。

Answer 2

我不得不在大型数据帧之间进行复制。我正在使用具有实时市场数据的数据帧，这可能不是大熊猫的设计目标，但这是我的经验..

在我的电脑上，使用.at复制一个数据点需要15μs，df大小可以忽略不计。 .loc至少需要550μs并且随着df变大而增加：3100μs将单个点从一个100000x2 df复制到另一个100000x2 df。 .ix似乎只比.loc快一点。

对于单个数据点.at非常快且不受数据帧大小的影响，但它无法处理范围因此需要循环，因此时间缩放是线性的。另一方面，.loc和.ix对于单个数据点（相对）非常慢，但是它们可以处理范围并且比线性扩展更好。但是，与.at不同，它们会大幅减慢数据帧大小。

因此，当我经常在大型数据帧之间复制小范围时，我倾向于使用带有for循环的.at，否则我将.ix用于范围。

for new_id in new_ids:
    for core_col in core_cols:
        df_large.at[new_id, core_col] = df_small.at[new_id, core_col]

当然，为了正确地做到这一点，我会选择上面的Jeff的解决方案，但是有选择权很好。

.at的注意事项：它不适用于范围，如果dtype是datetime（也许是其他人），则它不起作用。

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

2 个答案: