Python 3.x 如何计算列中的连续1并获得每组的最大计数

我有一个数据框，列为“A”和“flag”。我想应用groupby函数并获得每个组中连续1的最大计数

输入数据： 所需输出

---

通过和为每组的连续值创建

系列

，通过掩码

m

仅过滤

1

值，然后通过使用

max

对值进行计数，用于按原始列映射

A

：

IIUC，并且具有

级别=0

。 我们可以使用创建具有原始索引的系列：

blocks=df['flag'].ne(df['flag'].shift()).cumsum()
df['consecutive_count_max'] = (df['A'].map(df.groupby(['A',blocks])['flag']
                                             .sum()
                                             .max(level=0)))
print(df)

    A  flag  consecutive_count_max
0   1     1                      3
1   1     1                      3
2   1     0                      3
3   1     1                      3
4   1     1                      3
5   1     1                      3
6   2     0                      3
7   2     1                      3
8   2     1                      3
9   2     0                      3
10  2     1                      3
11  2     1                      3
12  2     1                      3

---

请注意，添加时，

flag==0

的组的总和永远不会大于

flag==1

的组，因此

df['flag']。不需要等式（1）

如果

flag

不是1或0，则有必要检查例如

df['flag'].eq（'yes'）

。我们可以使用：

mapper = pd.crosstab(df['flag'].ne(df['flag'].shift())
                               .cumsum()
                              .loc[df['flag'].eq(1)], df['A']).max()
df['consecituve_count_max'] = df['A'].map(mapper)
#print(df)

细节

print(df['flag'].ne(df['flag'].shift()).cumsum())

0     1
1     1
2     2
3     3
4     3
5     3
6     4
7     5
8     5
9     6
10    7
11    7
12    7
Name: flag, dtype: int64

---

我认为使用

Series.max

和

level=0

的解决方案是我的解决方案，如果OP使用标志0或1@ansev-嗯，我总是喜欢一般的解决方案，所以我添加了

eq（1）

。

blocks=df['flag'].ne(df['flag'].shift()).cumsum()
df['consecutive_count_max'] = (df['A'].map(df.groupby(['A',blocks])['flag']
                                             .sum()
                                             .max(level=0)))
print(df)

    A  flag  consecutive_count_max
0   1     1                      3
1   1     1                      3
2   1     0                      3
3   1     1                      3
4   1     1                      3
5   1     1                      3
6   2     0                      3
7   2     1                      3
8   2     1                      3
9   2     0                      3
10  2     1                      3
11  2     1                      3
12  2     1                      3

mapper = pd.crosstab(df['flag'].ne(df['flag'].shift())
                               .cumsum()
                              .loc[df['flag'].eq(1)], df['A']).max()
df['consecituve_count_max'] = df['A'].map(mapper)
#print(df)

print(df['flag'].ne(df['flag'].shift()).cumsum())

0     1
1     1
2     2
3     3
4     3
5     3
6     4
7     5
8     5
9     6
10    7
11    7
12    7
Name: flag, dtype: int64