你可以试试这个;1）创建一个额外的组变量df.value.diff().ne(0).cumsum()来表示值的变化;2）使用transform('size')计算组大小，并与3进行比较，然后得到所需的flag列：

df['flag'] = df.value.groupby([df.id, df.value.diff().ne(0).cumsum()]).transform('size').ge(3).astype(int) 
df

• 唐斯：

1)* diff不等于零 *（这就是df.value.diff().ne(0)的字面意思）给出了一个条件True，只要值发生变化：

df.value.diff().ne(0)
#0      True
#1     False
#2      True
#3      True
#4     False
#5     False
#6      True
#7     False
#8     False
#9     False
#10     True
#11     True
#12     True
#13    False
#14    False
#15     True
#16    False
#17     True
#18    False
#19    False
#20    False
#21    False
#Name: value, dtype: bool

2)然后cumsum给出id的非降序序列，其中每个id表示具有相同值的连续块，注意当对布尔值求和时，True被认为是1而False被认为是0：

df.value.diff().ne(0).cumsum()
#0     1
#1     1
#2     2
#3     3
#4     3
#5     3
#6     4
#7     4
#8     4
#9     4
#10    5
#11    6
#12    7
#13    7
#14    7
#15    8
#16    8
#17    9
#18    9
#19    9
#20    9
#21    9
#Name: value, dtype: int64

3)结合id列，可以对数据框进行分组，计算分组大小，得到flag列。

• • 请参阅EDIT2以获得更强大的解决方案**

结果相同，但速度稍快：

labels = (df.value != df.value.shift()).cumsum()
df['flag'] = (labels.map(labels.value_counts()) >= 3).astype(int)

    id  value  flag
0    1      2     0
1    1      2     0
2    1      3     0
3    1      2     1
4    1      2     1
5    1      2     1
6    1      3     1
7    1      3     1
8    1      3     1
9    1      3     1
10   2      1     0
11   2      4     0
12   2      1     1
13   2      1     1
14   2      1     1
15   2      4     0
16   2      4     0
17   2      1     1
18   2      1     1
19   2      1     1
20   2      1     1
21   2      1     1

其中：

1. df.value != df.value.shift()给出值变化
2. cumsum()为具有相同值的每个组创建"标签
3. labels.value_counts()统计每个标签的出现次数
4. labels.map(...)用上面计算的计数替换标签
5. >= 3在计数值上创建布尔掩码
6. astype(int)将布尔值强制转换为int
   在我的手中，它给你1.03毫秒的df，相比之下，2.1毫秒的心灵的做法。
   编辑：
   两种方法的混合甚至更快

labels = df.value.diff().ne(0).cumsum()
df['flag'] = (labels.map(labels.value_counts()) >= 3).astype(int)

使用样品df得到911 µ s。
EDIT2：正确的解决方案，以说明ID变更，如@clg4所示

labels = (df.value.diff().ne(0) | df.id.diff().ne(0)).cumsum()
df['flag'] = (labels.map(labels.value_counts()) >= 3).astype(int)

其中，... | df.id.diff().ne(0)在ID发生变化时递增标签
即使在ID更改时使用相同的值（在索引10上使用值3进行测试），这也能正常工作，并且耗时1.28ms
编辑3：更好的解释
假设索引10的值为3。df.id.diff().ne(0)

data={'id':[1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2],
      'value':[2,2,3,2,2,2,3,3,3,3,3,4,1,1,1,4,4,1,1,1,1,1]}
df=pd.DataFrame.from_dict(data)

df['id_diff'] = df.id.diff().ne(0).astype(int)
df['val_diff'] = df.value.diff().ne(0).astype(int)
df['diff_or'] = (df.id.diff().ne(0) | df.value.diff().ne(0)).astype(int)
df['labels'] = df['diff_or'].cumsum()

     id  value  id_diff  val_diff  diff_or  labels
 0    1      2        1         1        1       1
 1    1      2        0         0        0       1
 2    1      3        0         1        1       2
 3    1      2        0         1        1       3
 4    1      2        0         0        0       3
 5    1      2        0         0        0       3
 6    1      3        0         1        1       4
 7    1      3        0         0        0       4
 8    1      3        0         0        0       4
 9    1      3        0         0        0       4
>10   2      3        1    |    0    =   1       5 <== label increment
 11   2      4        0         1        1       6
 12   2      1        0         1        1       7
 13   2      1        0         0        0       7
 14   2      1        0         0        0       7
 15   2      4        0         1        1       8
 16   2      4        0         0        0       8
 17   2      1        0         1        1       9
 18   2      1        0         0        0       9
 19   2      1        0         0        0       9
 20   2      1        0         0        0       9
 21   2      1        0         0        0       9

|是"按位或"运算符，只要其中一个元素是True，它就给出True。因此，如果id变化的值没有差异，则|反映id变化。否则，它什么也不变化。当执行.cumsum()时，标签在id变化的地方递增。因此索引10处的值3不与来自索引6 - 9的值3分组。

#try this simpler version
a= pd.Series([1,1,1,2,3,4,5,5,5,7,8,0,0,0])
b= a.groupby([a.ne(0), a]).transform('size').ge(3).astype('int')
#ge(x) <- x is the number of consecutive repeated values 
print b

df=pd.DataFrame.from_dict(
        {'id':[1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2],
         'value':[2,2,3,2,2,2,3,3,3,3,1,4,1,1,1,4,4,1,1,1,1,1]})

df2 = df.groupby((df['value'].shift() != df['value']).\
                cumsum()).filter(lambda x: len(x) >= 3)

df['flag'] = np.where(df.index.isin(df2.index),1,0)

def function1(dd:pd.DataFrame):
      return dd.assign(flag=0) if len(dd)<3 else dd.assign(flag=1)

col1=df['value'].diff().ne(0).cumsum()
df.assign(flag=col1).groupby(['id','flag']).apply(function1)

输出：

id  value  flag
0    1      2     0
1    1      2     0
2    1      3     0
3    1      2     1
4    1      2     1
5    1      2     1
6    1      3     1
7    1      3     1
8    1      3     1
9    1      3     1
10   2      1     0
11   2      4     0
12   2      1     1
13   2      1     1
14   2      1     1
15   2      4     0
16   2      4     0
17   2      1     1
18   2      1     1
19   2      1     1
20   2      1     1
21   2      1     1