本教程详细介绍了如何在Pandas DataFrame中高效地识别并统计连续出现相同值的行数，并将这些计数作为一个新列添加。文章首先分析了常见的错误尝试，如全局计数和简单分组，然后深入讲解了如何通过结合使用`shift()`、`cumsum()`和`groupby().transform('size')`来精确地为每个连续块生成其对应的长度，从而解决这一常见的数据处理挑战。
引言
在数据分析和处理中，我们经常需要处理序列数据。其中一个常见需求是统计某个特定列中连续出现相同值的行数。例如，在一个日志文件中，我们可能想知道某个错误代码连续出现了多少次；或者在一个股票交易数据中，某个股票连续上涨或下跌了多少天。Pandas作为Python数据分析的核心库，提供了强大的工具来解决这类问题。本教程将指导您如何利用Pandas的特性，优雅地实现这一功能。
挑战：统计连续相同值
我们的目标是，给定一个DataFrame，其中包含一列数据（例如class），我们需要创建一个新列（例如consecutive_count），该列的每个值表示其所在行所属的连续相同值块的长度。
以下是我们期望的输出示例：
class consecutive_count a 3 a 3 a 3 b 2 b 2 c 1 d 1 e 3 e 3 e 3 f 1 a 1 c 1 d 2 d 2
常见误区与不足
在尝试解决这个问题时，初学者往往会遇到一些常见的误区。理解这些误区有助于我们更好地掌握正确的解决方案。
groupby().transform('count') 的局限性
一种常见的尝试是使用groupby()结合transform('count')。
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_attempt1'] = df.groupby('class')['class'].transform('count')
print(df)输出结果：
class consecutive_count_attempt1 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
这种方法的问题在于，transform('count')会计算整个DataFrame中每个类别的总出现次数，而不是仅仅计算连续出现的次数。例如，'a'在整个DataFrame中出现了4次，所以所有'a'都被标记为4，这与我们的需求不符。
shift().cumsum() 的分组作用
另一种尝试是利用shift()和cumsum()来识别连续块。
df['consecutive_group_id'] = (df['class'] != df['class'].shift()).cumsum() print(df)
输出结果：
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
这里，(df['class'] != df['class'].shift())会生成一个布尔序列，标记每个值是否与前一个值不同（即是否是新连续块的开始）。cumsum()则将这些布尔值（True为1，False为0）累加起来，从而为每个连续块分配一个唯一的ID。这非常接近我们的目标，因为它成功地将连续块区分开来。然而，它仅仅提供了分组ID，而不是每个组的计数。
核心解决方案
要精确地计算连续块的长度，我们需要结合上述两种思路的优点：首先识别出连续块，然后对这些连续块进行计数。
识别连续块的起始点
第一步是确定每个连续序列的起始位置。这可以通过比较当前行与前一行的数据来实现。如果它们不相同，则表示一个新的连续序列开始了。
# 标记新序列的开始 is_new_block = (df['class'] != df['class'].shift()) print(is_new_block)
输出（部分）：
0 True # 'a' 是第一个，与None不同 1 False # 'a' 与 'a' 相同 2 False # 'a' 与 'a' 相同 3 True # 'b' 与 'a' 不同 ...
为连续块分配唯一标识
接下来，我们将利用cumsum()将这些True（视为1）累加起来，为每个连续块生成一个唯一的标识符。
# 为每个连续块生成唯一ID block_id = (df['class'] != df['class'].shift()).cumsum() print(block_id)
输出（部分）：
0 1 1 1 2 1 3 2 ...
这个block_id是解决问题的关键，因为它将原始数据流中的所有连续相同元素有效地“分组”了。
计算每个连续块的大小
现在我们有了原始的class列以及为每个连续块生成的block_id。我们可以利用这两个信息进行分组，并计算每个组的大小。
我们将同时基于class列和block_id列进行分组。这样可以确保即使两个不连续的'a'块，也会因为它们的block_id不同而被视为不同的组。然后，使用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)
print("原始DataFrame:")
print(df)
print("-" * 30)
# 核心解决方案：
# 1. (df['class'] != df['class'].shift()) 生成一个布尔序列，标记每个新连续块的开始。
# 第一个元素通常是True（因为NaN != value）。
# 2. .cumsum() 将这些True/False（1/0）累加，为每个连续块分配一个唯一的整数ID。
# 3. df.groupby(['class', block_id]) 根据原始类别和连续块ID进行分组。
# 这确保了即使值相同但位置不连续的元素也会被分到不同的组。
# 4. .transform('size') 计算每个组的大小，并将结果广播回原始DataFrame的索引，
# 使得每个原始行都能得到其所属连续块的计数。
df['consecutive_count'] = df.groupby(['class', (df['class'] != df['class'].shift()).cumsum()]).transform('size')
print("\n结果DataFrame:")
print(df)输出结果：
原始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 ------------------------------ 结果DataFrame: 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
可以看到，最终结果与我们期望的完全一致。
总结与应用
通过结合shift()、cumsum()和groupby().transform('size')，我们能够高效且准确地统计Pandas DataFrame中连续相同值的行数。这种方法不仅适用于字符串类型的数据，也同样适用于数值类型。
关键点回顾：
- df.shift()：用于获取前一行的值，是识别序列变化的基石。
- df['col'] != df['col'].shift()：生成一个布尔序列，标记每个新连续块的起点。
- .cumsum()：将布尔序列转换为唯一的整数ID，从而将连续块逻辑地分组。
- df.groupby([original_col, block_id_col])：基于原始值和生成的块ID进行分组，确保了组的唯一性。
- .transform('size')：计算每个组的大小，并将结果“广播”回原始DataFrame的相应位置，保持了DataFrame的原始结构。
掌握这种模式对于处理时间序列数据、日志分析或任何需要识别和量化连续事件的场景都非常有用。它展示了Pandas在复杂数据操作方面的强大灵活性和表达力。
