创建一个新的列，通过重置另一个列的累计值，并根据某个条件进行操作。

Question

这是我的数据帧：

import pandas as pd 

df = pd.DataFrame(
    {
        'a': [98, 97, 100, 135, 103, 100, 105, 109, 130],
        'b': [100, 103, 101, 105, 110, 120, 101, 150, 160]
    }
)

我想要生成如下所示的输出结果，即创建一列 c：

     a    b    c
0   98  100  100
1   97  103  100
2  100  101  100
3  135  105  100
4  103  110  110
5  100  120  110
6  105  101  101
7  109  150  150
8  130  160  150

用纯英文描述这个问题对我来说有点复杂。列 c 本应是 df.b 的累积最小值（cumulative minimum），但在特定条件下会改变。我将逐行解释：

操作首先从计算累积最小值开始：

df['c'] = df.b.cummin()

改变 c 值的条件是：

cond = df.a.shift(1) > df.c.shift(1)

现在关键在于满足 cond == True 的行。对于这些行，我们令 df.c 等于 df.b，并且 b 列的累积最小值会在该位置重置。

例如，第一次满足条件 cond 的是在第 4 行，此时 c 的值变为 110（换句话说，c 取当前行的 b 值）。而对于下一行（第 5 行），c 的值将是自第 4 行起 b 列的新一轮累积最小值，依此类推直至最后一行。

这是我尝试的一种方法，但它在 cond 条件成立的地方未能正确工作：

df['c'] = df.b.cummin()
df.loc[df.a.shift(1) > df.c.shift(1), 'c'] = df.b

附注：

上述例子中接受的答案能够正常运行并达到预期结果。然而，在处理比这个示例大得多的实际数据时，该方法并未如预期那样工作。我尚未找到其中的问题所在。

不过我很喜欢这个答案，它在我的情况下能有效运作，并且简洁高效。尽管如此，我没有更改已接受的答案，因为它提供了一个向量化解决方案。

Yu Hao · Answer

代码

我无法找到一个使用向量化操作的方法来实现目标。尝试使用 while 循环：

df['c'] = None
while df['c'].isna().sum() > 0: 
    df2 = df[df['c'].isna()]
    s = df2['a'].gt(df2['b'].cummin()).shift(1).fillna(0).cumsum()
    idx = df2[s.eq(0)].index
    df.loc[idx, 'c'] = df.loc[idx, 'b'].cummin()

最终得到的 df 数据框：

    a   b   c
0   98  100 100
1   97  103 100
2   100 101 100
3   135 105 100
4   103 110 110
5   100 120 110
6   105 101 101
7   109 150 150
8   130 160 150

中间过程

首次执行 while 循环时的情况：

      df
    a   b   c         s
0   98  100 100       0
1   97  103 100       0
2   100 101 100       0
3   135 105 100       0
4   103 110 NaN       1
5   100 120 NaN       2
6   105 101 NaN       2
7   109 150 NaN       3
8   130 160 NaN       4

Shehata Gamal · Answer

我不确定是否可以对此进行向量化操作，但至少用纯Python编写起来相对简单，并且其时间复杂度为O(n)。

# 条件性累加最小值
k = None  # 用于第一个循环
c = []

for b, a_previous in zip(df['b'], df['a'].shift()):
    if k is None or b < k or a_previous > k:
        k = b
    c.append(k)

df.assign(c=c)

执行上述代码后，我们得到了期望的结果：

     a    b    c
0   98  100  100
1   97  103  100
2  100  101  100
3  135  105  100
4  103  110  110
5  100  120  110
6  105  101  101
7  109  150  150
8  130  160  150

如果你需要提升性能，可以考虑使用Cython或Numba等工具对代码进行优化以加快执行速度。这两种工具允许你将Python代码转换为更接近底层语言（如C或CUDA）的高性能代码，从而提高计算效率。

hakre · Answer

根据您的问题，您可以尝试以下操作：

# 创建第一个布尔掩码，当当前行的 'b' 列小于等于前一行的 'a' 列时为True
m1 = df['b'].le(df['a'].shift())

# 对 'b' 列应用分组累加最小值，依据的是 'm1' 掩码的累计和
cm = df['b'].groupby(m1.cumsum()).cummin()

# 创建第二个布尔掩码，当当前行的 'b' 列小于等于 'cm' 或者前一行的 'a' 列小于等于 'cm' 向左偏移一位时为True
m2 = (df['b'].le(cm) | df['a'].shift().le(cm.shift()))

# 使用 'cm' 的值填充 'c' 列，当 'm2' 为True时；当 'm2' 为False时，使用 'b' 列经过掩码后的累加最小值填充
df['c'] = cm.where(m2, df['b'].mask(m2).cummin())

执行上述代码后，您将得到包含中间步骤在内的输出结果：

     a    b    c    a_s     m1   cm     m2    c
0   98  100  100    NaN  False  100   True  100
1   97  103  100  98.00  False  100   True  100
2  100  101  100  97.00  False  100   True  100
3  135  105  100 100.00  False  100   True  100
4  103  110  110 135.00   True  110   True  110
5  100  120  110 103.00  False  110   True  110
6  105  101  101 100.00  False  101   True  101
7  109  150  150 105.00  False  101  False  150
8  130  160  150 109.00  False  101  False  150

[9行 x 8列]