pandas 过滤来自 dataframe 的行，连续差 < n

Question

I have a pandas dataframe as such:

id         time
1             1
2             3
3             4
4             5
5             8
6             8

and I want to drop rows that are less than 2 seconds apart. I started by computing the time diff between consecutive rows and adding it as a column:

df['time_since_last_detect'] = df.time.diff().fillna(0)

resulting in:

id         time       time_since_last_detect
1             1                            0
2             3                            2
3             4                            1
4             5                            1
5             8                            3
6             8                            0

and then filtering the rows using df[df.time_since_last_detect > 1] , which results in:

id         time       time_since_last_detect
2             3                            2
5             8                            3

The problem with this, however, is it does not recompute the difference from the new previous row once a row is dropped. For example, after removing the first and third rows, the difference between the second and the fourth will be 2. But the fourth row will be removed with this filter nevertheless, which I don't want to happen. What is the best way to solve this problem? This is the desired result I'm trying to achieve:

id         time       time_since_last_detect
2             3                            2
4             5                            1
5             8                            3

Answer 1

Not a perfect solution but you can do below in your case. Need to modify below to make a generic function.

import pandas as pd

d = {'id' : [1,2,3,4,5,6], 'time' : [1,3,4,5,8,8]}
df = pd.DataFrame(data =d)

df['time_since_last_detect'] = df.time.diff().fillna(0)
timeperiod = 2

df['time_since_last_sum'] =  df['time_since_last_detect'].rolling(min_periods=1, window=timeperiod).sum().fillna(0) # gets sum of rolling period , in this case 2. One case change as needed

df_final =  df.loc[(df['time_since_last_detect'] >= 2) | (df['time_since_last_sum'] == 2)] # Filter data with 2 OR condition 1. If last_detect>2 or last of 2 rolling period is 2 

Output:

   id  time  time_since_last_detect  time_since_last_sum
   2     3                     2.0                  2.0
   4     5                     1.0                  2.0
   5     8                     3.0                  4.0