Pandas DataFrame中实现条件性累积最小值重置_石家庄创泽智能科技有限公司

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Pandas DataFrame中实现条件性累积最小值重置

2025-11-23

浏览次数：次

返回列表

pandas dataframe中实现条件性累积最小值重置

本文详细讲解如何在Pandas DataFrame中根据复杂条件计算一个新列，该列的值是另一列的累积最小值，但在特定条件满足时，累积最小值会重置并从新值开始计算。通过分步解析和代码示例，文章展示了如何利用Pandas的向量化操作（如`shift`、`groupby`、`cumsum`、`cummin`、`where`和`mask`）来高效解决这类带有状态依赖的计算问题，避免了低效的循环，并提供了清晰的逻辑解释。

引言

在数据分析和处理中，我们经常需要对DataFrame中的数据进行累积计算，例如累积求和、累积最大值或累积最小值。然而，当这些累积计算需要根据特定条件进行“重置”时，问题会变得复杂。传统的累积函数通常是全局性的，不直接支持条件性重置。本文将探讨一个具体的场景：创建一个新列 c，它本质上是列 b 的累积最小值 (cummin())，但在满足某个条件时，这个累积最小值会从当前行的新值开始重新计算。

问题描述与示例数据

假设我们有一个Pandas DataFrame，包含两列 a 和 b：

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]
    }
)
print("原始DataFrame:")
print(df)

我们的目标是创建列 c，其计算规则如下：

c 的初始值是 df.b.cummin()。
存在一个条件 cond，当 cond 为 True 时，当前行的 c 值应等于当前行的 b 值，并且此后的累积最小值计算应从这个新的 c 值（即当前的 b 值）开始“重置”。
原始问题中描述的条件是 df.a.shift(1) > df.c.shift(1)。这个条件引入了一个挑战，因为它依赖于前一行的 c 值，使得直接的向量化计算变得困难。

期望的输出 df 如下所示：

     a    b    c
0   98  100  100
1   97  103  100
2  100  101  100
3  135  105  100
4  103  110  110  # 这里 'c' 从 100 变为 110，并重置
5  100  120  110
6  105  101  101  # 这里 'c' 从 110 变为 101，并重置
7  109  150  150  # 这里 'c' 从 101 变为 150，并重置
8  130  160  150

可以看到，在索引 4、6、7 处，列 c 的值发生了显著变化，并且其后的 cummin 操作似乎从这些新值开始。

解决方案：向量化方法

由于原始条件 df.a.shift(1) > df.c.shift(1) 具有递归性（c 依赖于其自身的前一个值），直接用 apply 或循环虽然可以实现，但在大数据集上效率低下。Pandas提供了强大的向量化工具，我们可以通过巧妙地构建辅助条件和分组操作来模拟这种重置行为。

以下是实现所需逻辑的向量化解决方案：

PictoGraphic

AI驱动的矢量插图库和插图生成平台

133 查看详情 PictoGraphic

# 步骤 1: 识别潜在的重置点
# 创建一个布尔掩码 m1，标记 b 列值是否小于或等于 a 列的上一行值。
# 这捕获了 b 可能开始一个新的累积最小值序列的场景。
m1 = df["b"].le(df["a"].shift())

# 步骤 2: 计算分组的累积最小值
# 使用 m1 的累积和 (cumsum) 来创建分组。
# 每当 m1 为 True 时，cumsum 会递增，从而创建一个新的组。
# 然后在每个组内计算 b 的累积最小值。
cm = df["b"].groupby(m1.cumsum()).cummin()

# 步骤 3: 确定何时使用分组累积最小值 (cm) 或重置后的累积最小值
# m2 是一个复合条件，用于最终决定 c 列的值来源。
# 它检查 b 是否小于或等于 cm，或者 a 的上一行是否小于或等于 cm 的上一行。
# 这个条件帮助我们精确地在需要重置时选择 b 的值，否则选择 cm 的值。
m2 = (df["b"].le(cm) | df["a"].shift().le(cm.shift()))

# 步骤 4: 构建最终的 c 列
# 使用 where 和 mask 结合 cm 和 b 的累积最小值。
# 如果 m2 为 True，则选择 cm 的值。
# 否则（m2 为 False），表示需要重置，此时我们从 b 列中选择值，
# 并对其进行累积最小值操作（mask(m2) 使得 m2 为 True 的位置变为 NaN，
# 这样 cummin() 就会跳过这些位置，从而实现从非 NaN 处开始的累积最小值）。
df["c"] = cm.where(m2, df["b"].mask(m2).cummin())

print("\n最终DataFrame (包含列 c):")
print(df)

详细步骤解析

为了更好地理解上述解决方案，我们逐步分析每个中间变量及其作用。

1. m1 = df["b"].le(df["a"].shift())

df["a"].shift()：将 a 列向下移动一行，第一行变为 NaN。
df["b"].le(...)：比较 b 列的当前值是否小于或等于 a 列的上一行值。
作用：m1 是一个布尔序列，用于标记潜在的“重置点”。当 b 的当前值比 a 的前一个值更小时，可能意味着一个新趋势的开始，从而需要重置累积最小值。

     a    b    a.shift()  m1
0   98  100        NaN  False
1   97  103       98.0  False  (103 <= 98.0) is False
2  100  101       97.0  False  (101 <= 97.0) is False
3  135  105      100.0  False  (105 <= 100.0) is False
4  103  110      135.0   True  (110 <= 135.0) is True
5  100  120      103.0  False  (120 <= 103.0) is False
6  105  101      100.0  False  (101 <= 100.0) is False
7  109  150      105.0  False  (150 <= 105.0) is False
8  130  160      109.0  False  (160 <= 109.0) is False

请注意，示例输出中的m1与实际计算结果略有不同，这是因为m1的逻辑可能需要根据实际业务含义进行微调。在提供的解决方案中，m1的目的是创建分组。

2. cm = df["b"].groupby(m1.cumsum()).cummin()

m1.cumsum()：对 m1 进行累积求和。每当 m1 中出现 True（被视为1）时，累积和就会增加1，从而为后续的 groupby 操作创建新的组ID。
- 例如：[False, False, False, False, True, False, False, False, False] 的 cumsum 会是 [0, 0, 0, 0, 1, 1, 1, 1, 1]。
df["b"].groupby(...).cummin()：根据 m1.cumsum() 生成的组ID，对 b 列进行分组，并在每个组内计算累积最小值。
作用：cm 列表示在由 m1 定义的重置点处重新开始计算的 b 列的累积最小值。

     a    b     m1  m1.cumsum()   cm
0   98  100  False            0  100
1   97  103  False            0  100
2  100  101  False            0  100
3  135  105  False            0  100
4  103  110   True            1  110  # m1为True，新组开始，cm从110开始
5  100  120  False            1  110
6  105  101  False            1  101  # 101 < 110，cm更新为101
7  109  150  False            1  101
8  130  160  False            1  101

3. m2 = (df["b"].le(cm) | df["a"].shift().le(cm.shift()))

这是一个复杂的布尔条件，结合了两个子条件：
- df["b"].le(cm)：b 的当前值是否小于或等于 cm 的当前值。
- df["a"].shift().le(cm.shift())：a 的上一行值是否小于或等于 cm 的上一行值。
作用：m2 是一个关键的决策掩码，它决定了最终 c 列的值应该来源于 cm（分组累积最小值）还是 df.b.mask(m2).cummin()（在 m2 为 False 的点重置的 b 的累积最小值）。这个条件精确地捕获了何时 cm 的值是有效的，以及何时需要进行更深层次的重置。

     a    b   cm  b.le(cm)  a.shift()  cm.shift()  a.shift().le(cm.shift())   m2
0   98  100  100      True        NaN         NaN                     False   True
1   97  103  100     False       98.0       100.0                      True   True
2  100  101  100     False       97.0       100.0                      True   True
3  135  105  100     False      100.0       100.0                      True   True
4  103  110  110      True      135.0       100.0                     False   True
5  100  120  110     False      103.0       110.0                      True   True
6  105  101  101      True      100.0       110.0                      True   True
7  109  150  101     False      105.0       101.0                     False  False  # b(150)不小于cm(101)，a.shift(105)不小于cm.shift(101)
8  130  160  101     False      109.0       101.0                     False  False  # b(160)不小于cm(101)，a.shift(109)不小于cm.shift(101)

4. df["c"] = cm.where(m2, df["b"].mask(m2).cummin())

df["b"].mask(m2)：当 m2 为 True 时，将 df["b"] 的对应位置替换为 NaN。
df["b"].mask(m2).cummin()：对处理后的 b 列计算累积最小值。由于 NaN 会被 cummin 跳过，这 effectively 实现了在 m2 为 False 的点开始新的累积最小值计算。
cm.where(m2, ...)：如果 m2 为 True，则 c 的值为 cm；如果 m2 为 False，则 c 的值为 df["b"].mask(m2).cummin() 的对应值。
作用：这是最终的组合步骤，它根据 m2 的真假，灵活地选择使用分组累积最小值 cm，还是在特定点重置并重新计算的 b 的累积最小值，从而精确地生成所需的 c 列。

完整代码与输出

将所有步骤整合到一起，并打印最终结果：

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]
    }
)

m1 = df["b"].le(df["a"].shift())
cm = df["b"].groupby(m1.cumsum()).cummin()
m2 = (df["b"].le(cm) | df["a"].shift().le(cm.shift()))
df["c"] = cm.where(m2, df["b"].mask(m2).cummin())

print(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

这个输出与期望的输出完全一致。

注意事项

shift() 引入的 NaN：shift() 操作会在第一行（或最后一行，取决于方向）引入 NaN。在布尔比较中，NaN 通常被视为 False，或者需要显式处理（例如使用 fillna()）。在这个解决方案中，Pandas 的操作会自动处理这些 NaN，使其行为符合预期。
条件复杂性：这个解决方案的巧妙之处在于将原始问题中递归的条件 df.a.shift(1) > df.c.shift(1) 转化为了一系列非递归的向量化操作。m1 和 m2 的设计是解决问题的核心。理解这些布尔掩码的逻辑是掌握此方法的关键。
性能：与基于循环的解决方案相比，这种向量化方法在处理大型数据集时具有显著的性能优势，因为它充分利用了Pandas底层C语言的优化。
通用性：虽然这个解决方案是针对特定条件设计的，但其核心思想——使用 groupby(mask.cumsum()).cummin() 来实现条件性重置的累积操作，以及使用 where() 和 mask() 进行条件性赋值——是解决类似问题的通用模式。

总结

本文详细介绍了如何在Pandas DataFrame中实现一个复杂的条件性累积最小值重置操作。通过构建辅助布尔掩码 (m1, m2) 和巧妙地结合 groupby(), cumsum(), cummin(), where(), mask() 等Pandas函数，我们成功地将一个看似需要递归或迭代的计算问题转化为了高效的向量化操作。这种方法不仅解决了特定问题，也展示了Pandas在处理复杂数据转换任务时的强大能力和灵活性。掌握这些高级技巧对于进行高效和专业的Python数据分析至关重要。

以上就是Pandas DataFrame中实现条件性累积最小值重置的详细内容，更多请关注其它相关文章！

# 创建一个 # 白帽seo价值 # seo 查询网站 # 老河口企业网站优化 # 江苏谷歌seo软件 # 普洱seo公司选择25火星 # 罗村网站推广推荐 # 企业网站如何推广困境 # 营销推广账户有哪些 # 上海云推广营销 # 三叶草网站建设 # 解决问题 # 所需 # python # 就会 # 掩码 # 但在 # 是一个 # 布尔 # 递归 # 最小值 # 工具 # app # 大数据 # c语言