使用.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模式。