Pandas分组比较相邻行生成新列方法

本教程深入解析了如何利用Pandas进行高级数据分析，重点讲解了在数据框中按组比较相邻行并生成新列的实用技巧。针对具有相同Race_ID的数据组，我们将学习如何比较当前行的C_k值与下一行的adv值，寻找满足特定条件（`adv_(n+1)

引言：问题背景与目标

在数据分析实践中，我们经常需要处理涉及跨行比较和分组聚合的复杂逻辑。例如，在一个按比赛ID和日期降序排列的数据集中，我们可能需要为每个比赛（Race_ID）确定一个特定的C_k值。这个C_k值的定义是：在该Race_ID组内，找到第一个满足条件 adv_(n+1) <= C_n 的行n，并取其对应的C_k值作为该组的C_t。如果一个组内没有行满足此条件，则C_t应默认为1。

这是一个典型的Pandas分组操作与行间比较结合的问题，需要灵活运用groupby、shift、条件筛选和值填充等功能。

数据准备

首先，我们创建一个示例Pandas DataFrame来模拟比赛数据，其中包含Race_ID、Date、adv和C_k列。

import pandas as pd
import io

data = """Race_ID   Date           adv          C_k
1         1/1/2023       2.5          2.7     
1         1/1/2023       1.4          2.6     
1         1/1/2023       1.3          1.9     
1         1/1/2023       1.1          1.2     
2         11/9/2022      1.4          1.1     
2         11/9/2022      1.3          1.2     
2         11/9/2022      1.0          0.4     
3         17/4/2022      0.9          0.2     
3         17/4/2022      0.8          0.4     
3         17/4/2022      0.7          0.5     
3         17/4/2022      0.6          0.2     
3         17/4/2022      0.5          0.4     
"""

df = pd.read_csv(io.StringIO(data), sep=r'\s\s+', engine='python')
df['Date'] = pd.to_datetime(df['Date'], format='%d/%m/%Y')

print("原始DataFrame:")
print(df)

原始DataFrame:

    Race_ID       Date  adv  C_k
0         1 2023-01-01  2.5  2.7
1         1 2023-01-01  1.4  2.6
2         1 2023-01-01  1.3  1.9
3         1 2023-01-01  1.1  1.2
4         2 2022-09-11  1.4  1.1
5         2 2022-09-11  1.3  1.2
6         2 2022-09-11  1.0  0.4
7         3 2022-04-17  0.9  0.2
8         3 2022-04-17  0.8  0.4
9         3 2022-04-17  0.7  0.5
10        3 2022-04-17  0.6  0.2
11        3 2022-04-17  0.5  0.4

方法一：条件筛选、去重与映射

这种方法的核心思想是：首先识别所有满足条件的行，然后从这些行中为每个组提取出我们所需的C_k值，最后将这些值映射回原始DataFrame。

核心步骤：

1. 获取下一行的adv值：使用groupby('Race_ID')['adv'].shift(-1)，在每个组内将adv列向下平移一位，从而获取下一行的adv值。
2. 构建布尔条件：将平移后的adv值与当前行的C_k值进行比较（<=），生成一个布尔Series。
3. 筛选符合条件的行：使用布尔索引从原始DataFrame中筛选出所有满足条件的行。
4. 提取目标C_k值：由于题目要求的是第一个满足条件的C_k值（即min{n| adv_(n+1) <= C_n}对应的C_k），并且我们的数据是按日期降序排列的，这意味着我们筛选出的行中，对于每个Race_ID，最后一个满足条件的行（keep='last'）就是我们需要的C_k值。
5. 映射与填充：将提取出的C_k值映射回原始DataFrame的Race_ID列，并使用fillna(1)处理那些没有找到匹配C_k值的组。

代码示例：

# 步骤1 & 2: 获取下一行的adv值并构建布尔条件
# df.groupby('Race_ID')['adv'].shift(-1) 获取每个组中下一行的adv值
# .le(df['C_k']) 比较下一行的adv是否小于等于当前行的C_k
condition = df.groupby('Race_ID')['adv'].shift(-1).le(df['C_k'])

# 步骤3 & 4: 筛选符合条件的行，然后去重以获取每个Race_ID的最后一个符合条件的C_k
# df[condition] 筛选出所有满足条件的行
# .drop_duplicates(subset=['Race_ID'], keep='last') 对于每个Race_ID，保留最后出现的行
# .set_index('Race_ID')['C_k'] 将Race_ID设为索引，并选择C_k列，生成一个Series
s = (df[condition]
     .drop_duplicates(subset=['Race_ID'], keep='last')
     .set_index('Race_ID')['C_k'])

# 步骤5: 映射并填充新列
# df['Race_ID'].map(s) 将Series s中的值根据Race_ID映射到新列
# .fillna(1) 对于没有匹配到的Race_ID（即s中不存在的Race_ID），填充默认值1
df['C_t_method1'] = df['Race_ID'].map(s).fillna(1)

print("\n方法一结果DataFrame:")
print(df)

结果DataFrame (方法一):

    Race_ID       Date  adv  C_k  C_t_method1
0         1 2023-01-01  2.5  2.7          1.9
1         1 2023-01-01  1.4  2.6          1.9
2         1 2023-01-01  1.3  1.9          1.9
3         1 2023-01-01  1.1  1.2          1.9
4         2 2022-09-11  1.4  1.1          1.2
5         2 2022-09-11  1.3  1.2          1.2
6         2 2022-09-11  1.0  0.4          1.2
7         3 2022-04-17  0.9  0.2          1.0
8         3 2022-04-17  0.8  0.4          1.0
9         3 2022-04-17  0.7  0.5          1.0
10        3 2022-04-17  0.6  0.2          1.0
11        3 2022-04-17  0.5  0.4          1.0

注意事项： drop_duplicates(keep='last') 在此处的关键作用是，由于我们寻找的是min{n| adv_(n+1) <= C_n}对应的C_k，并且数据是按日期降序排列的，这意味着行索引n越小代表时间越早，在满足条件的行中，索引最小的那一行（即最早满足条件的行）的C_k值才是我们想要的。当筛选出所有满足条件的行后，keep='last'实际上会保留这些满足条件的行中，在原始DataFrame中位置靠后的行。由于原始数据是按日期降序排列的，这意味着位置靠后的行对应的n值更小（即更早满足条件），因此keep='last'是正确的选择。

方法二：条件赋值与组内变换

这种方法利用Series.where()进行条件性赋值，然后通过groupby().transform('last')将组内的最后一个非NaN值广播到整个组。

核心步骤：

1. 条件性地保留C_k值：同样使用shift(-1)获取下一行的adv值，并构建布尔条件。然后，使用Series.where()函数，只有当条件为True时才保留C_k的原始值，否则将其替换为NaN。
2. 组内向下填充最后一个有效值：对处理后的C_k列按Race_ID分组，并使用transform('last')。transform('last')会将每个组中最后一个非NaN的值填充到该组的所有行中。
3. 填充默认值：最后，使用fillna(1)处理那些整个组都没有满足条件（即transform后仍然是NaN）的行。

代码示例：

# 步骤1: 条件性地保留C_k值
# df['C_k'].where(...) 只有当条件为True时保留C_k的值，否则为NaN
temp_C_k = df['C_k'].where(df.groupby('Race_ID')['adv'].shift(-1).le(df['C_k']))

# 步骤2: 组内向下填充最后一个有效值
# .groupby(df['Race_ID']).transform('last') 对每个Race_ID组，获取最后一个非NaN的值，并广播到整个组
transformed_C_k = temp_C_k.groupby(df['Race_ID']).transform('last')

# 步骤3: 填充默认值
df['C_t_method2'] = transformed_C_k.fillna(1)

print("\n方法二结果DataFrame:")
print(df)

结果DataFrame (方法二):

    Race_ID       Date  adv  C_k  C_t_method1  C_t_method2
0         1 2023-01-01  2.5  2.7          1.9          1.9
1         1 2023-01-01  1.4  2.6          1.9          1.9
2         1 2023-01-01  1.3  1.9          1.9          1.9
3         1 2023-01-01  1.1  1.2          1.9          1.9
4         2 2022-09-11  1.4  1.1          1.2          1.2
5         2 2022-09-11  1.3  1.2          1.2          1.2
6         2 2022-09-11  1.0  0.4          1.2          1.2
7         3 2022-04-17  0.9  0.2          1.0          1.0
8         3 2022-04-17  0.8  0.4          1.0          1.0
9         3 2022-04-17  0.7  0.5          1.0          1.0
10        3 2022-04-17  0.6  0.2          1.0          1.0
11        3 2022-04-17  0.5  0.4          1.0          1.0

两种方法比较与选择

• 可读性与简洁性：方法二（使用where和transform）通常被认为在代码结构上更为流畅和简洁，因为它使用了链式操作，减少了中间变量的创建。
• 性能：对于大多数中等规模的数据集，两种方法的性能差异不显著。在处理非常大的数据集时，Pandas的优化通常使得transform操作非常高效，因为它是在C语言层面实现的。方法一涉及创建临时DataFrame和进行多次索引操作，理论上可能略慢，但实际差异需通过性能测试确认。
• 灵活性：两种方法都非常灵活，可以适应不同的条件逻辑和填充策略。选择哪种方法更多取决于个人偏好和团队的代码风格。

总结

本教程展示了在Pandas数据框中处理复杂分组和跨行比较问题的两种高效策略。无论是通过条件筛选、去重与映射，还是通过条件赋值与组内变换，Pandas都提供了强大且灵活的工具集来解决这类数据操作挑战。理解groupby()、shift()、where()、transform()

今天关于《Pandas分组比较相邻行生成新列方法》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！