使用Pandas高效计算并添加DataFrame中连续行块的计数

本文详细介绍了如何在pandas dataframe中，为指定列的连续相同值序列计算其长度，并将此计数作为新列添加。通过结合使用shift()、cumsum()生成连续块的唯一标识，并利用groupby().transform('size')方法，文章提供了一种精确且高效的解决方案，适用于需要对数据中连续模式进行分析的场景。

理解连续行计数的挑战

在数据分析中，我们经常需要统计DataFrame中某一列连续相同值的出现次数。例如，在一个序列中，我们可能想知道'a'连续出现了多少次，然后'b'连续出现了多少次，以此类推。这与简单地统计某一值在整个列中出现的总次数有所不同。

常见误区及原因分析：

1. 使用 groupby().transform('count')： 直接使用 df.groupby('class')['class'].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['consecutive_count_wrong1'] = df.groupby('class')['class'].transform('count')
   print("错误示范1的输出：")
   print(df[['class', 'consecutive_count_wrong1']])

   登录后复制

   输出分析：

      class  consecutive_count_wrong1
   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，而不是第一次连续出现的3次和第二次连续出现的1次。

2. 使用 (df['class'] != df['class'].shift()).cumsum()： 这种方法是识别连续块的关键一步，它通过比较当前行与上一行是否相同来生成一个布尔序列，然后使用 cumsum() 将每个“变化点”累加，从而为每个连续块生成一个唯一的组ID。然而，这本身只是一个分组标识，并非连续计数。 示例代码（关键中间步骤）：

   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['consecutive_group_id'] = (df['class'] != df['class'].shift()).cumsum()
   print("\n中间步骤输出（连续组ID）：")
   print(df[['class', 'consecutive_group_id']])

   登录后复制

   输出分析：

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

   登录后复制

   可以看到，虽然它为每个连续块分配了唯一的ID（例如，前三个'a'都是ID 1，两个'b'是ID 2），但这个ID本身并不是我们想要的连续计数。

   

   AI帮个忙

   多功能AI小工具，帮你快速生成周报、日报、邮、简历等

   116

   查看详情

解决方案：结合分组标识与变换

要实现连续行计数，我们需要巧妙地结合上述第二种方法的思路，并在此基础上进行聚合。核心思想是：

1. 创建连续块的唯一标识： 利用 (df['class'] != df['class'].shift()).cumsum() 生成一个辅助列，该列为每个连续的相同值序列分配一个唯一的整数ID。
2. 基于复合键进行分组： 将原始的 class 列与这个新生成的连续块ID列组合起来，作为 groupby() 的键。这样，每个连续块（例如，第一个'a'序列，第二个'a'序列）都会被视为一个独立的组。
3. 应用 transform('size')： 对这些复合组执行 transform('size') 操作。transform('size') 会计算每个组的大小（即连续行的数量），并将这个结果广播回原始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: 创建连续块的唯一标识
# df['class'].shift() 将 'class' 列向下移动一行，用于比较当前行与上一行
# df['class'] != df['class'].shift() 比较当前行是否与上一行不同，生成布尔序列
# .cumsum() 对布尔序列进行累积求和，每当遇到 True (即发生变化) 时，计数器加1
# 这样就为每个连续的相同值块创建了一个唯一的整数ID
consecutive_group_id = (df['class'] != df['class'].shift()).cumsum()

# 步骤2: 基于原始 'class' 列和连续块ID进行分组，并计算每个组的大小
# df.groupby(['class', consecutive_group_id]) 结合 'class' 和 'consecutive_group_id' 作为分组键
# .transform('size') 计算每个组的元素数量，并将结果“转换”回原始DataFrame的对应位置
df['consecutive_count'] = df.groupby(['class', consecutive_group_id]).transform('size')

# 打印结果
print("最终结果：")
print(df[['class', 'consecutive_count']])

输出结果：

最终结果：
   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

这个输出与我们期望的结果完全一致。

注意事项与最佳实践

1. 性能考量： 对于非常大的DataFrame，shift() 和 groupby().transform() 操作可能会消耗一定的内存和计算资源。但在大多数实际应用中，Pandas的这些操作都是高度优化的。
2. 处理初始 NaN： df['class'].shift() 在DataFrame的第一行会产生 NaN。df['class'] != df['class'].shift() 会将 NaN != value 视为 True，因此 cumsum() 会从1开始。这通常是期望的行为，即第一行被视为一个新序列的开始。
3. 多列连续判断： 如果需要基于多列的组合来判断连续性，可以将多列放入 shift() 和比较操作中。例如： group_id = ((df['col1'] != df['col1'].shift()) | (df['col2'] != df['col2'].shift())).cumsum() 然后 df.groupby(['col1', 'col2', group_id]).transform('size')。
4. 数据类型： 这种方法适用于任何可比较的数据类型（字符串、数字、日期等）。

总结

本文详细阐述了如何在Pandas DataFrame中高效地计算并添加指定列的连续行计数。通过理解 shift()、cumsum() 在生成连续块标识中的作用，并结合 groupby().transform('size') 的强大功能，我们可以精确地解决这一常见的数据处理问题。这种技术不仅提高了数据分析的效率，也为更复杂的序列模式识别奠定了基础。掌握此方法，将有助于您在Pandas数据处理中更加游刃有余。

以上就是使用Pandas高效计算并添加DataFrame中连续行块的计数的详细内容，更多请关注php中文网其它相关文章！