Подсчет последовательных значений без перерыва в pandas/Python

Вот мое решение. Я очень старался сделать его более элегантным и эффективным, но не смог найти лучшего способа.

Я немного добавил к вашему образцу фрейма данных, так как продолжал думать о новых пограничных случаях. Один пограничный случай, который, я уверен, я не учел, заключается в том, что если последние 2+ теста для bike, test_type пройдены, полоса считается равной 0 (технически это не неправильно, просто зависит от формулировки данной задачи).

import pandas as pd
from io import StringIO
import numpy as np

raw = """ test_id  bike  test_type  test_result 
 1        a     slow       pass        
 1        a     fast       pass
 2        c     fast       fail
 2        c     slow       fail
 3        c     fast       fail
 3        c     slow       fail
 4        c     fast       fail
 4        c     slow       fail
 5        d     slow       fail
 5        d     fast       fail
 6        e     fast       pass
 6        e     slow       pass
 7        f     fast       fail
 7        f     slow       fail
 15       c     fast       pass
 15       c     slow       pass
 34       b     slow       fail        
 34       b     fast       fail        
 36       a     slow       pass        
 36       a     fast       pass        
 37       c     fast       fail        
 37       c     slow       fail        
 87       c     fast       fail        
 87       c     slow       fail
 88       f     fast      pass
 88       f     slow       pass
 99       b     slow       fail        
 99       b     fast       fail        
 124      b     slow       pass        
 124      b     fast       pass        
"""

df = pd.read_csv(StringIO(raw), sep='\s+')
g = ['bike', 'test_type']
df = df.set_index(['bike', 'test_type', 'test_result', 'test_id'])

#get the last test for the group and its result
last_test = df.reset_index(level=(2,3)).groupby(level=[0,1]).last()
out = last_test.rename({'test_result':'last_test_result', 'test_id': 'last_test_id'}, axis=1)

#find the last passing test for the group (NaN if none exist)
last_pass = df.xs('pass', level=2).reset_index(level=2).groupby(level=(0,1)).last()
out = out.join(last_pass.rename({'test_id': 'last_pass_id'},axis=1))

#find the second to last passing test for the group (NaN if none exist)
second_to_last_pass = df.xs('pass', level=2).reset_index(level=2).groupby(level=(0,1)).nth(-2)
out = out.join(second_to_last_pass.rename({'test_id': 'second_to_last_pass_id'}, axis=1))

#find the last failing test for the group (NaN if none exist)
last_fail = df.xs('fail', level=2).reset_index(level=2).groupby(level=(0,1)).last()
out = out.join(last_fail.rename({'test_id': 'last_fail_id'},axis=1))

#dropping all rows groups which haven't had a fail
out = out[~out['last_fail_id'].isnull()]

#if last_pass_id is NaN then we need to count from the beginning to last_test_id
out['last_pass_id'] = out['last_pass_id'].replace(np.NaN, -1).astype(int)

#if second_to_last_pass is NaN then we need to count from the beginning to last_pass_id
out['second_to_last_pass_id'] = out['second_to_last_pass_id'].replace(np.NaN, -1).astype(int)

#if last test was a fail then the streak is between last_pass_id and last_fail_id
out.loc[out['last_test_result']=='fail', 'lower_bound'] =  out[out['last_test_result']=='fail']['last_pass_id']
#if last test was a pass then the streak is between second_to_last_pass_id and last_fail_id
out.loc[out['last_test_result']=='pass', 'lower_bound'] =  out[out['last_test_result']=='pass']['second_to_last_pass_id']
out = out.drop(['last_test_id'], axis=1)

df = df.reorder_levels(['test_id','bike', 'test_type','test_result']).sort_index()
def func(row, df=df):
    bike, test_type = row.name
    df = df.xs(bike, level=1).xs(test_type, level=1).xs('fail', level=1)
    streak = (df.index > row.lower_bound).sum()
    return streak

out['fails_in_a_row'] = out.apply(func, axis=1)
out['ends_with_pass'] = out['last_test_result']=='pass'
out = out.drop(['last_pass_id', 'second_to_last_pass_id', 'lower_bound', 'last_fail_id', 'last_test_result'], axis=1)
out

Вот альтернативный подход:

rows = []
for (bike, test_type), sdf in df.groupby(["bike", "test_type"]):
    fails = sdf["test_result"] == "fail"
    if not fails.any(): continue
    groups = ((sdf["test_result"] != sdf["test_result"].shift())
              .fillna(True).cumsum())
    fails_in_a_row = groups[groups == groups[fails].iat[-1]].shape[0]
    ends_with_pass = sdf["test_result"].iat[-1] == "pass"
    rows.append([bike, test_type, fails_in_a_row, ends_with_pass])
columns = ["bike", "test_type", "fails_in_a_row", "ends_with_pass"]
out = pd.DataFrame(rows, columns=columns)

• Создавайте вложенные кадры данных sdf, группируя столбцы bike и test_type.
• Проверьте наличие "fail"s: если нет, пропустите итерацию.
• Определите связанные groups в столбце test_result (т.е. группы последовательных одинаковых значений).
• Теперь fails_in_a_row — это длина последней группы, соответствующей отказу. А ends_with_pass зависит от того, что последнее значение в столбце test_result равно "pass".