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

这里有一个替代方案。它可能适合也可能不适合您的数据模式。如果更新（你的小框架）几乎是独立的，这将起作用（IOW你没有更新大框架，然后选择一个新的子框架，然后更新等等 - 如果这是你的模式，那么使用@987654323 @ 差不多）。

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

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]

并在您需要时将所有内容连接在一起（同时它们保存在一个列表中，或者请参阅下面的我的 cmets，这些子帧可以在创建时移动到外部存储，然后在此连接步骤之前读回）。

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

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

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

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

这本质上是一种 map-reduce 模式。

Answer 2

快速：将列 a 和 b 从旧 df 复制到新 df。

df1 = df[['a', 'b']]

Answer 3

我不得不在大型数据帧之间进行相当多的复制。我正在使用带有实时市场数据的数据框，这可能不是 pandas 的设计目的，但这是我的经验..

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

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

因此，当我经常在大型数据帧之间复制小范围时，我倾向于将 .at 与 for 循环一起使用，否则我将 .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 是日期时间（可能还有其他），它也不起作用。