Панды вычисляют скользящее количество последовательных значений в пределах допуска

Обновлено:

Вот как это сделать (взяв последние предыдущие строки):

def last_within_range(df, target_col='req', tolerance=10):
    
    df = df.copy()
    s = pd.Series(dtype=int, index=df.index)
    
    # Get low and high tolerance
    df['lo'] = df[target_col] - df[target_col] * tolerance/100
    df['hi'] = df[target_col] + df[target_col] * tolerance/100
    
    # Find how many last rows the current value from `req` is within the desired range  
    for idx in df.index[1:]:
        past_idx = df.index[:df.index.get_loc(idx)]
        req = df.loc[idx, 'req']
        # Get bool values and identify groups to get the last one
        values = (req >= df.loc[past_idx, 'lo']) & (req <= df.loc[past_idx, 'hi'])
        grps = (values != values.shift()).cumsum()
        # If the last group is True, then get its sum
        s[idx] = grps.eq(grps.iloc[-1]).sum() if values.iloc[-1] == True else 0
        
    return df.assign(**{f'con{tolerance}': s})

last_within_range(df, tolerance=10)

Выход:

    req    lo    hi  con10
0    15  13.5  16.5      0
1    16  14.4  17.6      1
2    14  12.6  15.4      0
3    15  13.5  16.5      3
4    16  14.4  17.6      1
5    16  14.4  17.6      2
6    17  15.3  18.7      2
7    30  27.0  33.0      0
8    31  27.9  34.1      1
9    35  31.5  38.5      0
10   32  28.8  35.2      3
11   35  31.5  38.5      2
12   34  30.6  37.4      4
13   33  29.7  36.3      6
14   37  33.3  40.7      0

Однако он использует цикл :(

Оригинальный ответ:

Вы можете использовать функцию для вычисления lo и hi, а затем использовать их в цикле по индексам. Взгляните на следующую функцию:

def last_within_range(df, target_col='req', tolerance=10):
    
    df = df.copy()
    s = pd.Series(dtype=int, index=df.index)
    
    # Get low and high tolerance
    df['lo'] = df[target_col] - df[target_col] * tolerance/100
    df['hi'] = df[target_col] + df[target_col] * tolerance/100
    
    # Find how many last rows the current value from `req` is within the desired range  
    for idx in df.index:
        past_idx = df.index[:df.index.get_loc(idx)]
        req = df.loc[idx, 'req']
        s[idx] = (
            ((req >= df.loc[past_idx, 'lo']) & (req <= df.loc[past_idx, 'hi'])).sum()
        )
        
    return s # df.assign(**{f'con{tolerance}': s})

где он возвращает Series в качестве вывода. Так, например:

df['con5'] = last_within_range(df, tolerance=5)
df['con7'] = last_within_range(df, tolerance=7)
df['con10'] = last_within_range(df, tolerance=10)

    req  con5  con7  con10
0    15     0     0      0
1    16     0     1      1
2    14     0     1      1
3    15     1     2      3
4    16     1     3      3
5    16     2     4      4
6    17     0     3      3
7    30     0     0      0
8    31     1     1      1
9    35     0     0      0
10   32     1     2      3
11   35     1     1      2
12   34     2     3      4
13   33     2     5      6
14   37     0     2      3

Обратите внимание, что он не возвращает, сколько последовательных предыдущих строк находится в ожидаемом диапазоне, но возвращает, сколько из предыдущих строк соответствует вашим критериям.

Кроме того, если вы хотите увидеть вывод вместе с вычисленными lo и hi, вместо этого запустите return фрейм данных, заменив оператор return на df.assign(**{f'con{tolerance}': s}), а не s.