使用.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)，实际存储“数据库”，然后根据需要创建/更新子帧，然后在完成时写入新的存储。

我一直都在使用这种模式，尽管实际上是面板。对数据的一个子集执行计算，并将每个子集写入一个单独的文件

最后，将它们全部读入和concat(在内存中)，并写出一个巨大的新文件。concat步骤可以在内存中一次完成，或者如果是真正的大型任务，那么可以迭代完成。

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

这本质上是一个map reduce模式。