Pandas统计连续相同值并新增列技巧

本文针对Pandas DataFrame中统计连续相同值并新增列的需求，提出了一种高效的解决方案，符合百度SEO优化标准。传统`groupby`方法无法处理连续性计数，本文巧妙地结合`shift()`、`cumsum()`和`groupby().transform('size')`等Pandas核心函数，能够精确识别并计算每个连续值块的长度，并将其作为新列添加到DataFrame中。该方法简洁高效，避免了常见的`groupby().transform('count')`全局计数和单独使用`cumsum()`的误区，适用于需要对数据中连续模式进行分析的各种场景，例如时间序列分析、事件序列分析等。文章提供了详细的代码示例和步骤解释，帮助读者快速掌握这一实用技巧，提升数据处理效率。

本文介绍如何在Pandas DataFrame中高效统计某一列连续相同值的出现次数，并将其作为新列添加到DataFrame中。通过巧妙结合`shift()`、`cumsum()`和`groupby().transform('size')`等Pandas核心函数，我们可以精确地识别并计算出每个连续值块的长度，从而解决传统`groupby`无法处理连续性计数的问题。此方法简洁高效，适用于需要对数据中连续模式进行分析的场景。

Pandas中统计连续相同值出现次数的教程

在数据分析中，我们经常需要识别并统计数据集中连续出现相同值的模式。例如，在一个序列中，我们可能想知道某个值连续出现了多少次，并将这个计数作为一个新列添加到DataFrame中。本教程将详细介绍如何使用Pandas的强大功能来实现这一目标。

问题描述与目标

假设我们有一个Pandas DataFrame，其中包含一列数据，我们希望计算该列中每个值连续出现的次数，并将这个计数添加到DataFrame的另一列。

原始数据示例：

   class
0      a
1      a
2      a
3      b
4      b
5      c
6      d
7      e
8      e
9      e
10     f
11     a
12     c
13     d
14     d

期望输出示例：

   class  consecutive_count
0      a                  3
1      a                  3
2      a                  3
3      b                  2
4      b                  2
5      c                  1
6      d                  1
7      e                  3
8      e                  3
9      e                  3
10     f                  1
11     a                  1
12     c                  1
13     d                  2
14     d                  2

可以看到，当'a'连续出现三次时，对应的consecutive_count为3；当'b'连续出现两次时，为2；而当'a'再次出现但只出现一次时，其consecutive_count为1。这与简单的全局计数或累积计数有所不同。

常见的误区与不适用方法

在尝试解决此类问题时，初学者可能会想到以下两种常见方法，但它们并不能直接满足需求：

1. 使用 groupby().transform('count') 进行全局计数

这种方法会计算每个值在整个DataFrame中出现的总次数，而不是连续出现的次数。

import pandas as pd

data = {'class': ['a', 'a', 'a', 'b', 'b', 'c', 'd', 'e', 'e', 'e', 'f', 'a', 'c', 'd', 'd']}
df = pd.DataFrame(data)

df['total_count'] = df.groupby('class')['class'].transform('count')
print("使用 transform('count') 的结果:")
print(df)

输出结果：

使用 transform('count') 的结果:
   class  total_count
0      a            4
1      a            4
2      a            4
3      b            2
4      b            2
5      c            2
6      d            3
7      e            3
8      e            3
9      e            3
10     f            1
11     a            4
12     c            2
13     d            3
14     d            3

从结果可以看出，'a'的总计数是4，这包括了所有不连续的'a'。这不符合我们对“连续”计数的定义。

2. 使用 (df['class'] != df['class'].shift()).cumsum() 进行累积求和

这种方法非常接近我们的目标，它通过比较当前行与前一行是否相同来生成一个布尔序列，然后对这个布尔序列进行累积求和。其结果是为每个连续的块分配一个唯一的组ID。

df['consecutive_group_id'] = (df['class'] != df['class'].shift()).cumsum()
print("\n使用 cumsum() 生成组ID的结果:")
print(df)

输出结果：

使用 cumsum() 生成组ID的结果:
   class  total_count  consecutive_group_id
0      a            4                     1
1      a            4                     1
2      a            4                     1
3      b            2                     2
4      b            2                     2
5      c            2                     3
6      d            3                     4
7      e            3                     5
8      e            3                     5
9      e            3                     5
10     f            1                     6
11     a            4                     7
12     c            2                     8
13     d            3                     9
14     d            3                     9

这里的consecutive_group_id确实为每个连续的块创建了一个唯一的标识符。例如，前三个'a'都属于组1，接下来的两个'b'属于组2。这是解决问题的关键一步，但它本身并不是我们想要的计数。

正确的解决方案：结合 shift(), cumsum() 和 groupby().transform('size')

要获得每个连续块的计数，我们需要将上述第二种方法生成的组ID与原始的class列结合起来进行分组，然后计算每个组的大小。

核心思想：

1. 识别连续块的边界： 使用 df['class'] != df['class'].shift() 来判断当前行的值是否与前一行不同。当值发生变化时，布尔序列为True。
2. 为每个连续块生成唯一ID： 对上述布尔序列进行 cumsum()（累积求和）。True被视为1，False被视为0，因此每当值发生变化时，累积和就会增加1，从而为新的连续块分配一个唯一的ID。
3. 按“值”和“连续块ID”进行分组： 使用 df.groupby(['class', consecutive_group_id]) 同时按原始值和生成的连续块ID进行分组。这样可以确保即使值相同但位于不同的连续块中（例如第一个'a'块和第二个'a'块），它们也会被视为不同的组。
4. 计算每个组的大小并广播： 使用 transform('size') 计算每个组的大小。transform的特性是它会将计算结果广播回原始DataFrame的相应行，确保每个连续块的所有行都获得相同的计数。

完整实现代码：

import pandas as pd

# 示例数据
data = {'class': ['a', 'a', 'a', 'b', 'b', 'c', 'd', 'e', 'e', 'e', 'f', 'a', 'c', 'd', 'd']}
df = pd.DataFrame(data)

# 步骤1 & 2: 生成连续块的唯一ID
# (df['class'] != df['class'].shift()) 生成一个布尔序列，标记值何时发生变化
# .cumsum() 对此布尔序列进行累积求和，为每个连续块生成一个唯一的数字ID
consecutive_group_id = (df['class'] != df['class'].shift()).cumsum()

# 步骤3 & 4: 按 'class' 和 'consecutive_group_id' 分组，并计算每个组的大小
# df.groupby(['class', consecutive_group_id]) 创建了基于值和连续性的组
# .transform('size') 计算每个组的行数，并将结果广播回原始DataFrame的相应位置
df['consecutive_count'] = df.groupby(['class', consecutive_group_id]).transform('size')

print("最终结果:")
print(df)

输出结果：

最终结果:
   class  consecutive_count
0      a                  3
1      a                  3
2      a                  3
3      b                  2
4      b                  2
5      c                  1
6      d                  1
7      e                  3
8      e                  3
9      e                  3
10     f                  1
11     a                  1
12     c                  1
13     d                  2
14     d                  2

这正是我们期望的输出。

关键概念解析

• Series.shift(periods=1): 这个方法将Series中的数据向下移动指定的periods（默认为1）。例如，df['class'].shift()会将第一行的值变成NaN，第二行的值变成原第一行的值，以此类推。这对于比较当前行和前一行的数据非常有用。
• 布尔索引与 cumsum(): 当我们执行 df['class'] != df['class'].shift() 时，会得到一个布尔Series。True表示当前值与前一个值不同，False表示相同。对这个布尔Series执行 cumsum() 时，True被当作1，False被当作0。因此，每当遇到一个True（即值发生变化），累积和就会增加1，从而为新的连续块提供一个唯一的数字标识。
• DataFrame.groupby(by, ...): 这是一个强大的分组操作。当by参数是一个列表时，它会按照列表中所有元素的组合进行分组。在本例中，['class', consecutive_group_id] 确保了只有当class值和consecutive_group_id都相同时，行才会被分到同一个组。
• GroupBy.transform('size'): transform方法与apply类似，但它的一个关键特性是它必须返回一个与输入组具有相同索引的Series或DataFrame。'size'是transform的一个特殊参数，它会计算每个组的元素数量。然后，transform会将这个计算结果广播回原始DataFrame的相应位置，从而为属于同一组的所有行填充相同的值。

注意事项与总结

• 处理第一行： df['class'].shift() 会使第一行的值为NaN。在比较 df['class'] != df['class'].shift() 时，df['class'][0]（'a'）与 NaN 比较的结果是True。因此，cumsum() 会从1开始，为第一个连续块分配ID 1，这通常是我们期望的行为。
• 效率： 这种Pandas原生的矢量化操作通常比使用循环或自定义函数要高效得多，尤其是在处理大型数据集时。
• 灵活性： 这种方法不仅适用于字符串类型，也适用于任何可比较的数据类型（数字、日期等）。

通过结合shift()、cumsum()和groupby().transform('size')，我们能够优雅且高效地解决Pandas中统计连续相同值出现次数的问题。掌握这些Pandas核心函数的组合使用，将大大提升数据处理的灵活性和效率。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~