Question

我有年度数据。这些年中的每一年都存储在单独的数据框中。某些信息在某些年份缺失，但可能在其他年份可用。如果在缺失的一年之前和之后观察到信息，我只能信任这些信息。例如：

Index     Identifier      Date      Owner
 1           A             2005       F
 2           A             2006       NaN
 3           A             2007       F
 4           B             2005       G
 5           B             2006       NaN
 6           B             2007       NaN
 7           B             2008       G
 8           B             2009       NaN
 9           B             2010       F
 10          C             2006       H
 11          C             2007       NaN
 12          C             2008       NaN

这应该最终看起来像：

 Index     Identifier      Date      Owner
 1           A             2005       F
 2           A             2006       F
 3           A             2007       F
 4           B             2005       G
 5           B             2006       G
 6           B             2007       G
 7           B             2008       G
 8           B             2009       NaN
 9           B             2010       F
 10          C             2006       H
 11          C             2007       NaN
 12          C             2008       NaN

因此，只有在失踪年份之前和之后观察到同样的情况，才会有变化。如果我之后没有观察到任何事情，或者如果我观察到不同的事情，我就不应该做出改变。实际数据是每年约1000万次观测。因此循环效率非常低。

我目前的解决方案是：

framestot=(df2005, df2006, df2007, df2008, df2009, df2010)
df=pd.concat(framestot, ignore_index=True)
df=df.sort(columns='date', ascending=True, kind='quicksort')
df['lag'] = df.Owner 
df['lead'] = df.Owner
df['lag'] = df.groupby(['Identifier'])['lag'].transform(lambda grp: grp.fillna(method='ffill'))      
df['lead'] = df.groupby(['Identifier'])['lead'].transform(lambda grp: grp.fillna(method='bfill'))
df.loc[df['Owner'].isnull() & df['lead'] == df['lag'],'Owner'] = df.lag

这似乎是一种非常低效的解决方法。有没有办法直接调用这些信息？如果我没有弄错的话，这也会带来第一个非缺失的滞后和领先。我可以限制吗？例如，如果我只想在最近两年和未来两年内取代他们是相同的。如果数据来自两年多以前，我会保留缺失值。

Answer 1

一个简单的解决方案，虽然不是特别有效，但比较前向填充和后向填充：

In [11]: df['Owner'].ffill()
Out[11]:
0     F
1     F
2     F
3     G
4     G
5     G
6     G
7     G
8     F
9     H
10    H
11    H
Name: Owner, dtype: object

In [12]: ff = df['Owner'].ffill()

In [13]: ff[ff == df['Owner'].bfill()]
Out[13]:
0    F
1    F
2    F
3    G
4    G
5    G
6    G
8    F
9    H
Name: Owner, dtype: object

并将其拼接回原始列：

In [14]: df['Owner'] = ff[ff == df['Owner'].bfill()]

In [15]: df
Out[15]:
    Index Identifier  Date Owner
0       1          A  2005     F
1       2          A  2006     F
2       3          A  2007     F
3       4          B  2005     G
4       5          B  2006     G
5       6          B  2007     G
6       7          B  2008     G
7       8          B  2009   NaN
8       9          B  2010     F
9      10          C  2006     H
10     11          C  2007   NaN
11     12          C  2008   NaN

如果滞后和线索相同，则替换缺失值

1 个答案: