我想同步两个非常长的数据帧，性能是这个用例的关键。使用日期时间或时间戳，按时间顺序索引这两个数据帧（应该尽可能快地利用它）。
此示例中提供了一种同步方式：
import pandas as pd
df1=pd.DataFrame({'A':[1,2,3,4,5,6], 'B':[1,5,3,4,5,7]}, index=pd.date_range('20140101 101501', freq='u', periods=6))
df2=pd.DataFrame({'D':[10,2,30,4,5,10], 'F':[1,5,3,4,5,70]}, index=pd.date_range('20140101 101501.000003', freq='u', periods=6))
# synch data frames
df3=df1.merge(df2, how='outer', right_index=True, left_index=True).fillna(method='ffill')
我的问题是，这是否是最有效的方法？如果有更快的方法来解决这个任务，我准备探索其他解决方案（例如使用numpy或cython）。
由于
注意：时间戳通常不等间距（如上例所示），该方法在这种情况下也适用
阅读答案后的评论
我认为有很多用例既没有对齐也没有合并或加入帮助。关键是不要使用与数据库相关的语义进行对齐（在我看来，时间序列不是那么相关）。对我来说，对齐意味着将系列A映射到B并且有办法处理缺失值（通常是采样和保持方法），对齐和连接会导致不希望的效果，例如由于连接而重复的多个时间戳。我仍然没有一个完美的解决方案，但似乎np.searchsorted可以提供帮助（它比使用多个调用加入/对齐以执行我需要的要快得多）。到目前为止，我找不到大熊猫的方法。
如何将A映射到B以便B使得结果具有A和B的所有时间戳但没有重复（除了那些已经在A和B中的那些）？
另一个典型的用例是采样和保持同步，可以通过以下有效方式解决（与B同步A，即在A中的每个时间戳采用B中的相应值：
idx=np.searchsorted(B.index.values, A.index.values, side='right')-1
df=A.copy()
for i in B:
df[i]=B[i].ix[idx].values
结果df包含相同的A索引和B中的同步值。
有没有一种有效的方法直接在熊猫中做这些事情？
答案 0 :(得分：4)
如果您需要同步，请使用align，文档为here。否则合并是一个不错的选择。
In [18]: N=100000
In [19]: df1=pd.DataFrame({'A':[1,2,3,4,5,6]*N, 'B':[1,5,3,4,5,7]*N}, index=pd.date_range('20140101 101501', freq='u', periods=6*N))
In [20]: df2=pd.DataFrame({'D':[10,2,30,4,5,10]*N, 'F':[1,5,3,4,5,70]*N}, index=pd.date_range('20140101 101501.000003', freq='u', periods=6*N))
In [21]: %timeit df1.merge(df2, how='outer', right_index=True, left_index=True).fillna(method='ffill')
10 loops, best of 3: 69.3 ms per loop
In [22]: %timeit df1.align(df2)
10 loops, best of 3: 36.5 ms per loop
In [24]: pd.set_option('max_rows',10)
In [25]: x, y = df1.align(df2)
In [26]: x
Out[26]:
A B D F
2014-01-01 10:15:01 1 1 NaN NaN
2014-01-01 10:15:01.000001 2 5 NaN NaN
2014-01-01 10:15:01.000002 3 3 NaN NaN
2014-01-01 10:15:01.000003 4 4 NaN NaN
2014-01-01 10:15:01.000004 5 5 NaN NaN
... .. .. .. ..
2014-01-01 10:15:01.599998 5 5 NaN NaN
2014-01-01 10:15:01.599999 6 7 NaN NaN
2014-01-01 10:15:01.600000 NaN NaN NaN NaN
2014-01-01 10:15:01.600001 NaN NaN NaN NaN
2014-01-01 10:15:01.600002 NaN NaN NaN NaN
[600003 rows x 4 columns]
In [27]: y
Out[27]:
A B D F
2014-01-01 10:15:01 NaN NaN NaN NaN
2014-01-01 10:15:01.000001 NaN NaN NaN NaN
2014-01-01 10:15:01.000002 NaN NaN NaN NaN
2014-01-01 10:15:01.000003 NaN NaN 10 1
2014-01-01 10:15:01.000004 NaN NaN 2 5
... .. .. .. ..
2014-01-01 10:15:01.599998 NaN NaN 2 5
2014-01-01 10:15:01.599999 NaN NaN 30 3
2014-01-01 10:15:01.600000 NaN NaN 4 4
2014-01-01 10:15:01.600001 NaN NaN 5 5
2014-01-01 10:15:01.600002 NaN NaN 10 70
[600003 rows x 4 columns]
答案 1 :(得分：1)
如果您希望使用其中一个DataFrame的索引作为同步模式，可能很有用：
df3 = df1.iloc[df1.index.isin(df2.index),]
注意：我猜df1的形状＆gt;形状df2
在前面的代码片段中，您将获得df1和df2中的元素，但如果您想添加新索引，则可能更喜欢这样做：
new_indexes = df1.index.diff(df2.index) # indexes of df1 and not in df2
default_values = np.zeros((new_indexes.shape[0],df2.shape[1]))
df2 = df2.append(pd.DataFrame(default_values , index=new_indexes)).sort(axis=0)
您可以在此post
中看到另一种同步方式答案 2 :(得分：0)
对于我的观点，时间序列的同步是一个非常简单的过程。假设ts# (#=0,1,2)填充
ts#[0,:] - 时间
ts#[1,:] - 问
ts#[2,:] - 出价
ts#[3,:] - asksz
ts#[4,:] - bidz
输出
totts[0,:] - 同步时间
totts[1-4,:] - ts0
totts[5-8,:] - ts1
totts[9-12,:] - ts2
功能：
def syncTS(ts0,ts1,ts2):
ti0 = ts0[0,:]
ti1 = ts1[0,:]
ti2 = ts2[0,:]
totti = np.union1d(ti0, ti1)
totti = np.union1d(totti,ti2)
totts = np.ndarray((13,len(totti)))
it0=it1=it2=0
nT0=len(ti0)-1
nT1=len(ti1)-1
nT2=len(ti2)-1
for it,tim in enumerate(totti):
if tim >= ti0[it0] and it0 < nT0:
it0+=1
if tim >= ti1[it1] and it1 < nT1:
it1 += 1
if tim >= ti2[it2] and it2 < nT2:
it2 += 1
totts[0, it] = tim
for k in range(1,5):
totts[k, it] = ts0[k, it0]
totts[k + 4, it] = ts1[k, it1]
totts[k + 8, it] = ts2[k, it2]
return totts