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

现在，如果你看一下键＆＃34; B＆＃34;在原始数据框中，您将看到第5行的结束日期是05/31/2016，第6行的开始日期是2016年7月15日，因此这些记录不是连续的。日期为1.5个月。如果日期超过3天，我需要仅返回连续记录的最早开始日期，因此在这种情况下，所需的输出将是：

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

我一直试图使用＆＃39; shift＆＃39;计算每一行的开始日期和上一行的结束日期之间的天数的方法，但不确定我是否完全朝着正确的方向前进..或者我应该迭代行？我的数据框中有数十万条记录。

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

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获取EndDate的最大值和StartDate的min的元组

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

Pandas Dataframe - 具有条件/行迭代/上一行计算的最小函数

2 个答案: