What about:

import pandas

x = pandas.DataFrame({
    'x_1': [0, 1, 2, 3, 0, 1, 2, 500, ],},
    index=[0, 1, 2, 3, 4, 5, 6, 7])

x['x_1'].rolling(window=2).apply(lambda x: x.iloc[1] - x.iloc[0])

in general you can replace the lambda function with your own function. Note that in this case the first item will be NaN.

Update

Defining the following:

n_steps = 2
def my_fun(x):
    return x.iloc[-1] - x.iloc[0]

x['x_1'].rolling(window=n_steps).apply(my_fun)

you can compute the differences between values at n_steps.

Based your code (your groupby/apply), it looks like (despite your example ... but maybe I misunderstand what you want and then what Andy did would be the best idea) that you're working with a 'date' column that is a datetime64 dtype and not an integer dtype in your actual data. Also it looks like you want compute the change in days as measured from the first observation of a given group/stage. I think this is a better set of example data (if I understand your goal correctly):

>>> df

  group       date stage  dur
0     A 2014-01-01   one    0
1     A 2014-01-03   one    2
2     A 2014-01-04   one    3
3     A 2014-01-05   two    0
4     B 2014-01-02  four    0
5     B 2014-01-06  five    0
6     B 2014-01-10  five    4
7     C 2014-01-03   two    0
8     C 2014-01-05   two    2

Given that you should get some speed-up from just modifying your apply (as Jeff suggests in his comment) by dividing through by the timedelta64 in a vectorized way after the apply (or you could do it in the apply):

>>> df['dur'] = df.groupby(['group','stage']).date.apply(lambda x: x - x.iloc[0])
>>> df['dur'] /= np.timedelta64(1,'D')
>>> df

  group       date stage  dur
0     A 2014-01-01   one    0
1     A 2014-01-03   one    2
2     A 2014-01-04   one    3
3     A 2014-01-05   two    0
4     B 2014-01-02  four    0
5     B 2014-01-06  five    0
6     B 2014-01-10  five    4
7     C 2014-01-03   two    0
8     C 2014-01-05   two    2

But you can also avoid the groupby/apply given your data is in group,stage,date order. The first date for every ['group','stage'] grouping happens when either the group changes or the stage changes. So I think you can do something like the following:

>>> beg = (df.group != df.group.shift(1)) | (df.stage != df.stage.shift(1))
>>> df['dur'] = (df['date'] - df['date'].where(beg).ffill())/np.timedelta64(1,'D')
>>> df

  group       date stage  dur
0     A 2014-01-01   one    0
1     A 2014-01-03   one    2
2     A 2014-01-04   one    3
3     A 2014-01-05   two    0
4     B 2014-01-02  four    0
5     B 2014-01-06  five    0
6     B 2014-01-10  five    4
7     C 2014-01-03   two    0
8     C 2014-01-05   two    2

Explanation: Note what df['date'].where(beg) creates:

>>> beg = (df.group != df.group.shift(1)) | (df.stage != df.stage.shift(1))
>>> df['date'].where(beg)

0   2014-01-01
1          NaT
2          NaT
3   2014-01-05
4   2014-01-02
5   2014-01-06
6          NaT
7   2014-01-03
8          NaT

And then I ffill the values and take the difference with the 'date' column.

Edit: As Andy points out you could also use transform:

>>> df['dur'] = df.date - df.groupby(['group','stage']).date.transform(lambda x: x.iloc[0])
>>> df['dur'] /= np.timedelta64(1,'D')

  group       date stage  dur
0     A 2014-01-01   one    0
1     A 2014-01-03   one    2
2     A 2014-01-04   one    3
3     A 2014-01-05   two    0
4     B 2014-01-02  four    0
5     B 2014-01-06  five    0
6     B 2014-01-10  five    4
7     C 2014-01-03   two    0
8     C 2014-01-05   two    2

Speed: I timed the two method using a similar dataframe with 400,000 observations:

Apply method:

1 loops, best of 3: 18.3 s per loop

Non-apply method:

1 loops, best of 3: 1.64 s per loop

So I think avoiding the apply could give some significant speed-ups

You can use:

df['no_trading'] = df['Sell'].replace({0:np.nan, 1:'no_trade'}).fillna(df['Buy'].replace({1:'bought'})).astype(str).replace('0', np.nan).ffill()
df['no_trading'] = df['no_trading'].mask(((df['no_trading'] == 'no_trade') & (df['Sell'] == 1)), 'sold')


df['unique_buys'] = df['Buy'].replace(0, np.nan).cumsum().ffill()
df['profit'] = df.groupby('unique_buys')[['Close']].apply(lambda x: x-x.iloc[0])
df['profit'] = df['profit'].mask(df['no_trading'] == 'no_trade', np.nan)
df.drop(columns=['no_trading', 'unique_buys'], inplace=True)
print(df)

OUTPUT

        date  Close  Buy  Sell  profit
0 2020-10-01     90    0     0     NaN
1 2020-10-02     91    1     0     0.0
2 2020-10-03     89    0     0    -2.0
3 2020-10-04     92    0     1     1.0
4 2020-10-05     93    0     0     NaN
5 2020-10-06     92    0     0     NaN
6 2020-10-07     94    1     0     0.0
7 2020-10-08     91    0     0    -3.0
8 2020-10-09     89    0     1    -5.0

First, we build an intermediate DataFrame that have nonzero grades. Since 1s and -1s always alternate, it suffices to analyze the difference between consecutive grade values.

Again, since 1s and -1s alternate, the difference between consecutive scores can be either -2 or 2, so depending on what it is, we can identify whether it is an up row or a down row.

tmp = df.loc[df['grade'].ne(0), ['score','grade']].diff()
down_idx = tmp['grade'].lt(0).loc[lambda x: x].index
df.loc[down_idx, 'down'] = tmp.loc[down_idx, 'score']
up_idx = tmp['grade'].gt(0).loc[lambda x: x].index
df.loc[up_idx, 'up'] = tmp.loc[up_idx, 'score']

Output:

  name  score  grade  down   up
0  ann   23.3      0   NaN  NaN
1  bob   36.5      0   NaN  NaN
2  don   29.3      1   NaN  NaN
3  jul   45.8      0   NaN  NaN
4  ken   36.2     -1   6.9  NaN
5  nic   38.9      1   NaN  2.7
6  pal   16.7      0   NaN  NaN
7  qiu   32.5     -1  -6.4  NaN
8  sun   33.9      0   NaN  NaN
9  tom   28.5      1   NaN -4.0