如果列值大于其他值，如何在python中创建累积总和列

Question

我现在正在使用 Pandas 获取累积总和列。 但是，仅当其他列值大于其他列值时，此列才包括累积总和。 这是我当前数据的示例：

Index     A       B       C
0         1       20      3
1         10      15      11
2         20      12      25
3         30      18      32
4         40      32      17
5         50      12      4

然后我想cumsum()列A如果B列大于C ，如果不是值为零。 原始df结果列D应如下所示：

Index     A       B       C      D
0         1       20      3      1
1         10      15      11     11
2         20      12      25     0
3         30      18      32     0
4         40      32      17     40
5         50      12      4      90

我提前感谢任何支持。

Answer 1

可能有更优雅的解决方案，但这也有效。

我们首先创建两个虚拟列 - x 和 x_shift。

df.x 是有条件的，我们保留 df.A 的值，其中 df.B > df.C。

df.x_shift 是我们将值向下移动一行并用 0 填充 na 的地方。

在最后一步，我们有条件地添加 df.A 和 df.x_shift，然后删除 df.x 和 df.x_shift

df['x'] = pd.DataFrame(np.where(df.B>df.C, df.A ,0))
df['x_shift'] = df.x.shift(1).fillna(0)
df['D'] = pd.DataFrame(np.where(df.B >df.C, df.A+df.x_shift,0))
df= df.drop(['x','x_shift'], axis=1

Answer 2

df = pd.DataFrame({'A': {0: 1, 1: 10, 2: 20, 3: 30, 4: 40, 5: 50},
                   'B': {0: 20, 1: 15, 2: 12, 3: 18, 4: 32, 5: 12},
                   'C': {0: 3, 1: 11, 2: 25, 3: 32, 4: 17, 5: 4}})

为您的条件制作一个布尔系列并识别连续的真或假组

b_gt_c = df.B > df.C
groups = b_gt_c.ne(b_gt_c.shift()).cumsum()

In [107]: b_gt_c
Out[107]: 
0     True
1     True
2    False
3    False
4     True
5     True
dtype: bool

In [108]: groups
Out[108]: 
0    1
1    1
2    2
3    2
4    3
5    3
dtype: int32

按这些组分组； 将每组的cumsum乘以条件； 将结果分配给新的 df 列。

gb = df.groupby(groups)
for k,g in gb:
    df.loc[g.index,'D'] = g['A'].cumsum() * b_gt_c[g.index]

In [109]: df
Out[109]: 
    A   B   C     D
0   1  20   3   1.0
1  10  15  11  11.0
2  20  12  25   0.0
3  30  18  32   0.0
4  40  32  17  40.0
5  50  12   4  90.0

您也可以跳过 for 循环：

df['G'] = np.where(df.B.gt(df.C), df.A, np.NaN)
group = df.B.gt(df.C).ne(df.B.gt(df.C).shift()).cumsum()
df['G'] = df.groupby(group).G.cumsum().fillna(0)

---

从 SO Q&A 中识别连续出现的值： 根据连续出现的值对数据框进行分组

Answer 3

虽然它有点野蛮，但您可以转换为 numpy 数组，然后编写一个简单的 catch 来遍历 3 个数组并比较值。