根据列中的1和0重置累计计数。

Question

 {"categ": [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 "value":  [0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
 "Run_count":  [0, 1, 1, 0, 0, 2, 0, 3, 0, 0, 0, 4, 4, 0, 0, 0, 0, 5, 5, 0, 0, 6],
 "currentResults":  [0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 0, 0, 5, 5, 5, 5, 6, 6, 6],
 "desiredResults":  [0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 0, 0, 0, 0, 1, 1, 2, 2, 2],
 })

data['Run_count'] = data['value'].where(data['value'].eq(1)).dropna().groupby(data['value'].where(data['value'].eq(1)).isna().cumsum()).ngroup()+1
data['currentResults'] = np.where(data['categ']==1,data['Run_count'].bfill(),0)

我基本上已经实现了目标数据，即在data['currentResults']中展示的内容。然而，我还想达成一个新的目标，在索引值为15且 df['categ'] 为 1 的位置上，我想让 data['desiredCount'] 中的计数重新开始。由于在索引 13 至 14 处，df['categ'] 的值为 0，目前在索引为 15 时，data['currentResults'] 继续计数为 "5"，而我希望计数从 1 重新开始。

我认为根据我当前的代码，最容易实现这个目标的方式可能是基于某些条件在 “Run_count” 列中重置/重启计数器。

附图展示了我希望在 “desiredResults” 列中实现的效果：

简而言之，我想要在遇到连续的 categ 为 0 的行之后，当再次遇到 categ 变为 1 时，对应的 desiredResults 计数值能从 1 开始重新计数。

siride · Answer

以下是一个解决方案，它遍历“categ”和“value”两个系列中每一对值。

# 初始化运行计数器变量
run_count = 0  # 用于记录当前连续计数

# 创建一个列表来记录每个值对的运行计数
results = []

# 定义一个变量存储前一组值以进行比较
[prev_categ, prev_value] = [None, None]

# 遍历数据集中 'categ' 和 'value' 列的每一对值
for categ, value in data[['categ', 'value']].values:

    # 当遇到 categ 和 value 同时为 0 时，重置计数器
    if [categ, value] == [0, 0]:
        run_count = 0
        
    # 如果当前值对是第一个出现的 (1, 1)，则增加计数
    if ([categ, value] == [1, 1]) and ([categ, value] != [prev_categ, prev_value]):
        run_count += 1
    
    # 将当前计数值添加到结果列表中
    results.append(run_count)
    
    # 更新前一组值
    [prev_categ, prev_value] = [categ, value]

# 将计算得到的运行计数赋值给数据集的新列 'run_count'
data['run_count'] = results

# 输出更新后的数据集
data

输出结果如下：

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

Andy E · Answer

如果我的理解正确，您可以创建布尔型Series，然后使用自定义的 https://pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.transform.html" rel="nofollow noreferrer">groupby.transform 方法：

m1 = data['value'].ne(1)
m2 = data['categ'].ne(1)

data['out'] = (m1[~m2]
               .groupby(m2.cumsum())
               # 在每次遇到非1值后累加1
               .transform(lambda g: (g & ~g.shift(fill_value=False)).cumsum()
               # 若分组起始处为非1，则加上1
                                    + (1 - g.iloc[0]))
               .reindex(data.index, fill_value=0)  # 若categ为非1，则填充为0
              )

输出结果：

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

中间步骤：

    categ  value     m1     m2  m2.cumsum()  g&~g_shift  out
0       0      0   True   True            1        NaN    0
1       1      1  False  False            1      False    1
2       1      1  False  False            1      False    1
3       1      0   True  False            1       True    2
4       1      0   True  False            1      False    2
5       1      1  False  False            1      False    2
6       1      0   True  False            1       True    3
7       1      1  False  False            1      False    3
8       1      0   True  False            1       True    4
9       1      0   True  False            1      False    4
10      1      0   True  False            1      False    4
11      1      1  False  False            1      False    4
12      1      1  False  False            1      False    4
13      0      0   True   True            2        NaN    0
14      0      0   True   True            3        NaN    0
15      1      0   True  False            3       True    1
16      1      0   True  False            3      False    1
17      1      1  False  False            3      False    1
18      1      1  False  False            3      False    1
19      1      0   True  False            3       True    2
20      1      0   True  False            3      False    2
21      1      1  False  False            3      False    2

针对更新的问题

对于您更新的问题，似乎只需要更改 m1 的条件并移除 +(1-g.iloc[0])) 这一修正因子即可：

m1 = data['value'].eq(1)
m2 = data['categ'].ne(1)

data['out'] = (m1[~m2]
               .groupby(m2.cumsum())
               # 在每次遇到1之后的非1值后累加1
               .transform(lambda g: (g & ~g.shift(fill_value=False)).cumsum())
               .reindex(data.index, fill_value=0)  # 若categ为非1，则填充为0
              )

输出结果：

    categ  value  desiredResults  out
0       0      0               0    0
1       1      1               1    1
2       1      1               1    1
3       1      0               1    1
4       1      0               1    1
5       1      1               2    2
6       1      0               2    2
7       1      1               3    3
8       1      0               3    3
9       1      0               3    3
10      1      0               3    3
11      1      1               4    4
12      1      1               4    4
13      0      0               0    0
14      0      0               0    0
15      1      0               0    0
16      1      0               0    0
17      1      1               1    1
18      1      1               1    1
19      1      0               2    1  # 不过此处与desiredResults不同！
20      1      0               2    1
21      1      1               2    2