python - 在按其他列和相对位置加权的同时对列进行滚动求和

Question

我有一张这样的 table :

import pandas as pd
values = [0,0,0,2000,0,0,700,0,0,530,1000,820,0,0,200]
durations = [0,0,0,12,0,0,8,0,0,2,5,15,0,0,3]

ex = pd.DataFrame({'col_to_roll' : values, 'max_duration': durations})

    col_to_roll  max_duration
0             0             0
1             0             0
2             0             0
3          2000            12
4             0             0
5             0             0
6           700             8
7             0             0
8             0             0
9           530             2
10         1000             5
11          820            15
12            0             0
13            0             0
14          200             3

对于每一行位置 i，我想在索引 i-7 和 i- 之间做一个 col_to_roll 的滚动总和4(都包括在内)。需要注意的是，我希望根据 max_duration 列(它说明该值在未来有多少时间步仍然有效)计算得更多。
有一个更高的界限，即要计算的剩余时间步长(最小 1，最大 4)。因此，如果我在第 7 行进行汇总:第 1 行的值将被计算为 min(max_duration[1],4)，第 2 行的值将是计算 min(max_duration[2],3) 等

我可以用蛮力的方式做到:

new_col = []
for i in range(7,len(ex)) : 
    rolled_val = sum([ex.iloc[j].col_to_roll*min(ex.iloc[j].max_duration , i-j+1-4) \
                     for j in range(i-7,i-3)])
    new_col.append(rolled_val)
ex['rolled_col'] = [np.nan]*7+new_col

从上面的例子中得到以下结果:

        col_to_roll  max_duration  rolled_col
    0             0             0         NaN
    1             0             0         NaN
    2             0             0         NaN
    3          2000            12         NaN
    4             0             0         NaN
    5             0             0         NaN
    6           700             8         NaN
    7             0             0      2000.0
    8             0             0      4000.0
    9           530             2      6000.0
    10         1000             5      8700.0
    11          820            15      1400.0
    12            0             0      2100.0
    13            0             0      3330.0
    14          200             3      2060.0

话虽这么说，我希望有一种更优雅(更重要的是，更有效)的方式来使用 pandas 魔术来获得此结果。

Answer 1

只是为了分享我的想法，这可以通过使用不带 for 循环的 numpy 来解决

import numpy as np

ex_len = ex.shape[0]
inds = np.vstack([range(i-7,i-3) for i in range(7,ex_len)])
# part one 
col_to_roll = np.take(ex.col_to_roll.values,inds)
# part two
max_duration = np.take(ex.max_duration.values,inds)
duration_to_compare = np.array([[i-j+1-4 for j in range(i-7,i-3)]for i in range(7,ex_len)])
min_mask = max_duration > duration_to_compare
max_duration[min_mask] = duration_to_compare[min_mask]

new_col = np.sum(col_to_roll*max_duration,axis=1)
ex['rolled_col'] = np.concatenate(([np.nan]*7,new_col))