Pandas中基于类别变化的滚动差值计算

本文详细介绍了如何在pandas dataframe中高效计算一个数值列（如时间戳）相对于其所属分组起始值的差值，其中分组的定义是基于另一个分类列连续值变化的。通过利用`groupby.transform('first')`和`cumsum()`等pandas向量化操作，可以避免低效的循环，实现高性能的数据处理。

引言：高效计算基于类别变化的滚动差值

在数据分析和处理中，我们经常会遇到需要计算某个数值序列相对于特定事件发生时间点的差值。一个常见的场景是，当数据集中存在一个分类变量时，我们希望计算另一个数值变量（例如时间戳）自该分类变量上一次发生变化以来的累计差值。例如，在一个包含传感器读数的数据集中，我们可能需要计算每个读数距离当前“模式”开始的时间。如果直接使用循环遍历DataFrame的每一行来判断分类变量是否变化并进行计算，这在处理大型数据集时会非常低效。本教程将展示如何利用Pandas库的向量化操作，以一种高性能的方式解决这个问题。

问题描述

假设我们有一个Pandas DataFrame，其结构如下：

其中：

• A 是一个分类变量，表示某个类别或状态。
• t 是一个数值变量，通常表示时间戳（单位为秒）。
• X 是我们期望计算的输出列，它表示自列A的值上一次发生变化以来的秒数。当A的值发生变化时，X应重置为0。

我们的目标是填充列X，使其准确反映自A列值变化以来的时间差。

解决方案：利用Pandas向量化操作

Pandas提供了一系列强大的向量化操作，可以高效地处理这类问题。核心思路是首先识别出A列连续值相同的各个“组”，然后对于每个组，找到其t列的第一个值（即该组的起始时间），最后用当前行的t值减去该组的起始时间。

以下是实现这一目标的具体步骤和代码：

步骤一：识别连续相同的分组

为了将A列中连续相同的值划分为不同的组，我们可以利用shift()和ne()（不等于）方法来检测A列值何时发生变化，然后使用cumsum()来为每个连续的组生成一个唯一的标识符。

• df['A'].shift()：将A列向下移动一行，这样可以比较当前行与上一行的值。
• df['A'].ne(df['A'].shift())：创建一个布尔序列，当当前行A的值与上一行不同时为True，否则为False。这准确标记了A列值发生变化的位置。
• .cumsum()：对布尔序列进行累积求和。由于True被视为1，False被视为0，每当A列值发生变化（即True出现）时，累积和就会增加1，从而为每个连续的组分配一个唯一的整数ID。

import pandas as pd

# 示例数据
data = {
    'A': [1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 2, 1, 1],
    't': [0.0, 3.2, 3.9, 18.0, 27.4, 47.4, 50.2, 57.2, 64.8, 76.4, 80.5, 85.3, 87.4]
}
df = pd.DataFrame(data)

# 步骤一：识别连续相同的分组
group = df['A'].ne(df['A'].shift()).cumsum()
print("分组标识符 (group):\n", group)

输出的group序列将如下所示：

分组标识符 (group):
 0     1
 1     1
 2     1
 3     1
 4     1
 5     2
 6     2
 7     2
 8     2
 9     2
 10    3
 11    4
 12    4
Name: A, dtype: int64

可以看到，A列值为1的第一个连续块被标记为组1，A列值为3的连续块被标记为组2，依此类推。

AI Sofiya

一款AI驱动的多功能工具

109

查看详情

步骤二：获取每个组的起始时间

接下来，我们需要为每个识别出的组获取其t列的第一个值。groupby().transform('first')方法非常适合这个任务：

• df.groupby(group)：根据上一步生成的group标识符对DataFrame进行分组。
• ['t'].transform('first')：对每个分组的t列应用transform('first')操作。transform方法会将结果广播回原始DataFrame的形状，这意味着对于每个组内的所有行，它都会返回该组t列的第一个值。

# 步骤二：获取每个组的起始时间
first_t_per_group = df.groupby(group)['t'].transform('first')
print("\n每个组的起始时间 (first_t_per_group):\n", first_t_per_group)

输出的first_t_per_group序列将如下所示：

每个组的起始时间 (first_t_per_group):
 0     0.0
 1     0.0
 2     0.0
 3     0.0
 4     0.0
 5    47.4
 6    47.4
 7    47.4
 8    47.4
 9    47.4
 10   80.5
 11   85.3
 12   85.3
Name: t, dtype: float64

现在，first_t_per_group序列中的每一行都对应着它所属分组的起始时间。

步骤三：计算滚动差值

最后一步是计算当前行的t值与它所属组的起始时间之间的差值。这可以通过简单的列相减来完成：

# 步骤三：计算滚动差值
df['X'] = df['t'].sub(first_t_per_group)
print("\n最终结果 (df):\n", df)

完整代码示例

将以上步骤整合到一起，完整的解决方案代码如下：

import pandas as pd

# 示例数据
data = {
    'A': [1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 2, 1, 1],
    't': [0.0, 3.2, 3.9, 18.0, 27.4, 47.4, 50.2, 57.2, 64.8, 76.4, 80.5, 85.3, 87.4]
}
df = pd.DataFrame(data)

# 1. 识别连续相同的分组
# 当'A'列的值与上一行不同时，生成True，然后累积求和作为分组标识符
group = df['A'].ne(df['A'].shift()).cumsum()

# 2. 获取每个组的起始时间
# 对每个分组，获取't'列的第一个值，并将其广播回原始DataFrame的形状
first_t_per_group = df.groupby(group)['t'].transform('first')

# 3. 计算滚动差值
# 用当前行的't'值减去其所属组的起始时间
df['X'] = df['t'].sub(first_t_per_group)

print(df)

输出结果

运行上述代码将得到以下DataFrame：

    A      t      X
0   1    0.0    0.0
1   1    3.2    3.2
2   1    3.9    3.9
3   1   18.0   18.0
4   1   27.4   27.4
5   3   47.4    0.0
6   3   50.2    2.8
7   3   57.2    9.8
8   3   64.8   17.4
9   3   76.4   29.0
10  2   80.5    0.0
11  1   85.3    0.0
12  1   87.4    2.1

结果中的X列准确地反映了自A列值上一次变化以来的时间差。例如，当A从1变为3时（索引5），X重置为0；当A从3变为2时（索引10），X再次重置为0。

注意事项与总结

1. 性能优势： 这种方法完全基于Pandas的向量化操作，避免了Python原生的for循环，因此在处理大型数据集时具有显著的性能优势。
2. 数据类型： 确保用于计算差值的列（例如t）是数值类型。如果它是字符串或其他非数值类型，需要先进行类型转换。
3. shift()的默认行为： shift()在第一行会引入NaN。ne()与NaN的比较结果通常是True（因为NaN != anything，包括NaN自身），这使得第一个分组的标识符从1开始，符合预期。
4. 通用性： 这种模式不仅限于计算时间差，也可以用于计算其他数值相对于组内第一个值的差值、比例或其他统计量，只要将transform('first')替换为其他聚合函数（如transform('mean'), transform('min')等）即可。

通过掌握groupby().transform()与shift().cumsum()的组合使用，您可以高效地解决许多涉及基于连续分组进行计算的数据处理问题，极大地提升数据分析的效率和代码的简洁性。

以上就是Pandas中基于类别变化的滚动差值计算的详细内容，更多请关注php中文网其它相关文章！