Pandas条件性列生成：利用where与填充方法处理行间依赖

在数据处理中，我们经常会遇到需要根据复杂逻辑生成新列的场景。有时，新列的值不仅取决于当前行的特定属性，还可能需要引用其上方或下方（即前一个或后一个）行的值。传统上，这可能导致使用循环迭代dataframe，但这种方法在处理大型数据集时效率低下。pandas提供了强大的向量化操作，可以优雅地解决这类问题。

场景描述

假设我们有一个Pandas DataFrame，其中包含两列：Colonne 1 和 Dimension 1。我们的目标是创建一个名为 new 的新列，其填充逻辑如下：

1. 如果当前行的 Dimension 1 列的值为 'Organisation'，则 new 列的值直接取自当前行的 Colonne 1 列。
2. 如果当前行的 Dimension 1 列的值不为 'Organisation'（例如为 'Indicator'），则 new 列的值应取自其最近的下一个（在索引上）值为 'Organisation' 的行的 Colonne 1 值。

以下是示例DataFrame：

  Colonne 1   Dimension 1
0  MTN_LI2      Indicator
1  MTN_IRU      Indicator
2  MTN_ACE      Indicator
3  MTN_IME      Indicator
4     RIPP7  Organisation
5    CA_SOT     Indicator
6    CA_OTI     Indicator
7     CNW00  Organisation
8     BSNTF  Organisation
9     RIPNJ  Organisation

解决方案：结合 Series.where() 与填充方法

解决此类问题的关键在于利用Pandas的 Series.where() 方法进行条件筛选，并结合 Series.bfill()（反向填充）或 Series.ffill()（正向填充）来处理行间依赖。

1. 使用 Series.where() 筛选目标值

Series.where(cond, other=nan) 方法会根据条件 cond 返回一个与原Series相同大小的Series。如果条件为 True，则保留原Series的值；如果条件为 False，则用 other（默认为 NaN）填充。

对于我们的问题，我们首先筛选出 Dimension 1 为 'Organisation' 的行，并将其 Colonne 1 的值保留下来，其他行则标记为 NaN：

import pandas as pd
import io

data = """  Colonne 1   Dimension 1
0  MTN_LI2      Indicator
1  MTN_IRU      Indicator
2  MTN_ACE      Indicator
3  MTN_IME      Indicator
4     RIPP7  Organisation
5    CA_SOT     Indicator
6    CA_OTI     Indicator
7     CNW00  Organisation
8     BSNTF  Organisation
9     RIPNJ  Organisation
"""
df = pd.read_csv(io.StringIO(data), sep='\s\s+', engine='python')

# 步骤1：根据条件保留值，不满足条件的设为NaN
# 只有当 'Dimension 1' == 'Organisation' 时，才保留 'Colonne 1' 的值
# 否则，该位置将是 NaN
temp_series = df['Colonne 1'].where(df['Dimension 1'].eq('Organisation'))
print("中间结果 (temp_series):")
print(temp_series)

输出 temp_series 如下：

中间结果 (temp_series):
0      NaN
1      NaN
2      NaN
3      NaN
4    RIPP7
5      NaN
6      NaN
7    CNW00
8    BSNTF
9    RIPNJ
Name: Colonne 1, dtype: object

可以看到，只有 Dimension 1 为 'Organisation' 的行保留了 Colonne 1 的值，其余都变成了 NaN。

2. 使用 Series.bfill() 填充缺失值（向前填充）

Series.bfill()（backward fill）方法用于填充Series中的 NaN 值。它会从当前 NaN 值的位置开始，向后（即沿着索引递增的方向）查找第一个非 NaN 值，并用该值填充当前的 NaN。这正是我们所需的“取最近的下一个组织值”的逻辑。

GPTKit

一个AI文本生成检测工具

108

查看详情

df['new_bfill'] = df['Colonne 1'].where(df['Dimension 1'].eq('Organisation')).bfill()

print("\n使用 bfill() 的结果:")
print(df)

输出结果：

使用 bfill() 的结果:
  Colonne 1   Dimension 1 new_bfill
0  MTN_LI2      Indicator     RIPP7
1  MTN_IRU      Indicator     RIPP7
2  MTN_ACE      Indicator     RIPP7
3  MTN_IME      Indicator     RIPP7
4     RIPP7  Organisation     RIPP7
5    CA_SOT     Indicator     CNW00
6    CA_OTI     Indicator     CNW00
7     CNW00  Organisation     CNW00
8     BSNTF  Organisation     BSNTF
9     RIPNJ  Organisation     RIPNJ

解释：

• 对于索引0到3的行，Dimension 1 是 'Indicator'，它们在 temp_series 中是 NaN。bfill() 会从这些位置向后查找，直到找到索引4的 RIPP7，然后用 RIPP7 填充索引0到3的 NaN。
• 对于索引5和6的行，Dimension 1 也是 'Indicator'，它们在 temp_series 中是 NaN。bfill() 会向后查找，直到找到索引7的 CNW00，然后用 CNW00 填充索引5和6的 NaN。

3. 使用 Series.ffill() 填充缺失值（向后填充）

虽然题目描述更倾向于 bfill() 的效果，但了解 ffill()（forward fill）也很有用。Series.ffill() 方法用于填充Series中的 NaN 值。它会从当前 NaN 值的位置开始，向前（即沿着索引递减的方向）查找第一个非 NaN 值，并用该值填充当前的 NaN。这意味着它会使用最近的前一个有效值。

df['new_ffill'] = df['Colonne 1'].where(df['Dimension 1'].eq('Organisation')).ffill()

print("\n使用 ffill() 的结果:")
print(df)

输出结果：

使用 ffill() 的结果:
  Colonne 1   Dimension 1 new_bfill new_ffill
0  MTN_LI2      Indicator     RIPP7       NaN
1  MTN_IRU      Indicator     RIPP7       NaN
2  MTN_ACE      Indicator     RIPP7       NaN
3  MTN_IME      Indicator     RIPP7       NaN
4     RIPP7  Organisation     RIPP7     RIPP7
5    CA_SOT     Indicator     CNW00     RIPP7
6    CA_OTI     Indicator     CNW00     RIPP7
7     CNW00  Organisation     CNW00     CNW00
8     BSNTF  Organisation     BSNTF     BSNTF
9     RIPNJ  Organisation     RIPNJ     RIPNJ

解释：

• 对于索引0到3的行，由于它们前面没有 Organisation 类型的行，ffill() 无法找到前一个有效值，因此这些 NaN 值会保留下来。
• 对于索引5和6的行，ffill() 会向前查找，找到索引4的 RIPP7，然后用 RIPP7 填充。

根据原始问题“Else the cell gets the value of the upper cell”，如果“upper cell”指的是“最近的下一个有效值”（即向下查找，然后向上填充），那么 bfill() 是正确的选择。如果指的是“最近的前一个有效值”（即向上查找，然后向下填充），那么 ffill() 则是适用的。在实际应用中，请根据具体业务逻辑选择 bfill() 或 ffill()。

注意事项与总结

1. 向量化操作的效率： 这种方法利用了Pandas底层的C语言优化，相比于Python循环，在处理大量数据时具有显著的性能优势。
2. 中间 NaN 的作用： where() 方法将不满足条件的值转换为 NaN 是关键一步，它为后续的填充操作提供了明确的标记。
3. bfill() 与 ffill() 的选择：
   • bfill()：向后查找非 NaN 值，并向前填充。适用于“取最近的下一个有效值”的场景。
   • ffill()：向前查找非 NaN 值，并向后填充。适用于“取最近的前一个有效值”的场景。
   • 需要注意，如果 ffill() 遇到Series开头的 NaN 且前面没有有效值，这些 NaN 将保持不变。同样，如果 bfill() 遇到Series末尾的 NaN 且后面没有有效值，这些 NaN 也将保持不变。
4. 默认行为： bfill() 和 ffill() 默认会填充整个Series。如果需要在分组内进行填充，可以结合 groupby() 使用。

通过巧妙地结合 Series.where() 和 Series.bfill() 或 Series.ffill()，我们可以高效且优雅地解决Pandas DataFrame中涉及条件判断和行间依赖的复杂列生成问题，极大地提升数据处理的效率和代码的简洁性。

以上就是Pandas条件性列生成：利用where与填充方法处理行间依赖的详细内容，更多请关注php中文网其它相关文章！