PANDAS DataFrame-条件/行迭代/PREV行计算的最小功能

Question

我有一个数据框，该记录的开始和结束日期：

import pandas as pd
df = pd.DataFrame({'Key': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B' ], 
             'StartDate': ['01/01/2015', '01/01/2016', '06/01/2016','10/01/2017', 
                           '01/01/2015', '01/01/2016', '07/15/2016','10/01/2017'], 
               'EndDate': ['12/30/2015', '05/31/2016', '09/30/2017', '12/31/2018', 
                           '12/30/2015', '05/31/2016', '09/30/2017', '12/31/2018']})
df = df[['Key', 'StartDate', 'EndDate']]
print(df)

我的输出看起来像这样：

 Key   StartDate     EndDate
0   A  01/01/2015  12/30/2015
1   A  01/01/2016  05/31/2016
2   A  06/01/2016  09/30/2017
3   A  10/01/2017  12/31/2018
4   B  01/01/2015  12/30/2015
5   B  01/01/2016  05/31/2016
6   B  07/15/2016  09/30/2017
7   B  10/01/2017  12/31/2018

我需要知道每个键的最早开始日期和最新结束日期。我这样做了(请让我知道是否有更好的方法来实现此目的(：

df_start = df.groupby('Key')['StartDate'].min().reset_index(name = 'StartDate')
df_end = df.groupby('Key')['EndDate'].max().reset_index(name = 'EndDate')
final = pd.merge(df_start, df_end, on = 'Key', how = 'left')
print(final)

这给了我这个输出：

  Key   StartDate     EndDate
0   A  01/01/2015  12/31/2018
1   B  01/01/2015  12/31/2018

现在，如果您在原始数据框架中查看键" b"，您将看到第5行的结束日期为05/31/2016，第6行的开始日期为07/15/2016，所以这些记录不是连续的。日期为1.5个月。如果日期有超过3天的休息，我需要仅返回连续记录的最早开始日期，因此在这种情况下，所需的输出将为：

Key   StartDate     EndDate
    0   A  01/01/2015  12/31/2018
    1   B  07/15/2016  12/31/2018

我一直在尝试使用'Shift'方法来计算每行开始日期和上一行的结束日期之间的天数，但不确定我是否完全朝着正确的方向前进。。或者我应该在行上迭代？我的数据框架中有数十万个记录。

实现这一目标的最有效方法是什么？谢谢。

Answer 1

好吧，您需要为定义的连续记录创建标记，然后删除重复：

df['StartDate'] = pd.to_datetime(df['StartDate'])
df['EndDate'] = pd.to_datetime(df['EndDate'])
consec = (df.groupby('Key').apply(lambda x: x.StartDate - x.EndDate.shift(1) >= pd.Timedelta('3 day'))
            .cumsum().reset_index(drop=True))
(df.groupby(['Key',consec])
   .agg({'StartDate':'min','EndDate':'max'})
   .reset_index()
   .drop_duplicates('Key', keep='last')
   .drop('level_1', axis=1))

输出：

  Key  StartDate    EndDate
0   A 2015-01-01 2018-12-31
2   B 2016-07-15 2018-12-31

Answer 2

我绝不是熊猫专家，但我认为我有一些可以做你想要的东西。首先，我将日期转换为日期：

df['StartDate'] = pd.to_datetime(df['StartDate'], infer_datetime_format=True)
df['EndDate'] = pd.to_datetime(df['EndDate'], infer_datetime_format=True)
print(df)

结果：

  Key  StartDate    EndDate
0   A 2015-01-01 2015-12-30
1   A 2016-01-01 2016-05-31
2   A 2016-06-01 2017-09-30
3   A 2017-10-01 2018-12-31
4   B 2015-01-01 2015-12-30
5   B 2016-01-01 2016-05-31
6   B 2016-07-15 2017-09-30
7   B 2017-10-01 2018-12-31

然后确定每组末端和开始日期之间的时间量：

df['Break'] = (df.groupby('Key')
    .apply(lambda d: d['StartDate'] - d['EndDate'].shift(1))
    .reset_index(level=0, name='Break')['Break']
)
print(df)

结果：

  Key  StartDate    EndDate   Break
0   A 2015-01-01 2015-12-30     NaT
1   A 2016-01-01 2016-05-31  2 days
2   A 2016-06-01 2017-09-30  1 days
3   A 2017-10-01 2018-12-31  1 days
4   B 2015-01-01 2015-12-30     NaT
5   B 2016-01-01 2016-05-31  2 days
6   B 2016-07-15 2017-09-30 45 days
7   B 2017-10-01 2018-12-31  1 days

查找休息时间高于我们所需的截止的位置：

cutoff = pd.Timedelta('3 days')
df['Break_above_cutoff'] = df['Break'] > cutoff
print(df)

结果：

  Key  StartDate    EndDate   Break  Break_above_cutoff
0   A 2015-01-01 2015-12-30     NaT               False
1   A 2016-01-01 2016-05-31  2 days               False
2   A 2016-06-01 2017-09-30  1 days               False
3   A 2017-10-01 2018-12-31  1 days               False
4   B 2015-01-01 2015-12-30     NaT               False
5   B 2016-01-01 2016-05-31  2 days               False
6   B 2016-07-15 2017-09-30 45 days                True
7   B 2017-10-01 2018-12-31  1 days               False

然后，我定义此功能以找到从该数据框开始的部分列中包含true的最后一行：

def get_after_last_true(df, colname):
"""Gets the portion of the dataframe starting from the last occurance of 
   True in colname"""
   idx = np.where(df[colname])[0]
   if len(idx) > 0:
       return df.iloc[idx[-1]:]
   else:
       return df

将其应用于组：

trimmed = (df.groupby('Key')
         .apply(lambda d: get_after_last_true(d, 'Break_above_cutoff'))
         .reset_index(drop=True)
      )
print(trimmed)

结果：

  Key  StartDate    EndDate   Break  Break_above_cutoff
0   A 2015-01-01 2015-12-30     NaT               False
1   A 2016-01-01 2016-05-31  2 days               False
2   A 2016-06-01 2017-09-30  1 days               False
3   A 2017-10-01 2018-12-31  1 days               False
4   B 2016-07-15 2017-09-30 45 days                True
5   B 2017-10-01 2018-12-31  1 days               False

然后只使用groupby-apply来获取最大终点的元组和startdate的最小值

result = trimmed.groupby('Key').apply(
    lambda df: (df['StartDate'].min(), df['EndDate'].max())
)
print(result)

结果：

Key
A    (2015-01-01 00:00:00, 2018-12-31 00:00:00)
B    (2016-07-15 00:00:00, 2018-12-31 00:00:00)
dtype: object