DataFrame多列键值映射技巧

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《高效映射DataFrame多列键值对方法》，聊聊，我们一起来看看吧！

本教程探讨了在Pandas DataFrame中根据特定“键”列的值，有条件地映射或填充多个目标列的专业方法。针对传统`numpy.select`重复操作的低效性，文章详细介绍了两种高性能的向量化解决方案：一是利用`pd.get_dummies`和`df.mask`构建布尔掩码进行条件替换；二是采用`melt`、`merge`和`unstack`进行数据重塑与过滤。这些方法能显著提升处理效率，尤其适用于大数据集。

引言：DataFrame多列条件映射的挑战

在数据处理中，我们经常遇到这样的场景：需要根据DataFrame中某一“键”列的值，有条件地处理其他多个列的数据。例如，如果key列的值是'key1'，则colA和colD应保留其原始值，而colB和colC则应填充为'NA'。如果key列的值是'key2'，则colB保留原值，其他列填充'NA'，以此类推。

传统的做法可能涉及对每个目标列单独使用numpy.select或循环遍历，但这在处理大量列或大规模数据集时效率低下且代码冗余。例如，以下代码展示了这种重复性操作：

import pandas as pd
import numpy as np

# 创建示例DataFrame
data = {
    'key': ['key1', 'key2', 'key3', 'key1', 'key2'],
    'colA': ['value1A', 'value2A', 'value3A', 'value4A', 'value5A'],
    'colB': ['value1B', 'value2B', 'value3B', 'value4B', 'value5B'],
    'colC': ['value1C', 'value2C', 'value3C', 'value4C', 'value5C'],
    'colD': ['value1D', 'value2D', 'value3D', 'value4D', 'value5D']
}
df = pd.DataFrame(data)

# 应用条件和选择到各自的列
df['colA'] = np.select([df['key'] == 'key1'], [df['colA']], default='NA')
df['colD'] = np.select([df['key'] == 'key1'], [df['colD']], default='NA')
df['colB'] = np.select([df['key'] == 'key2'], [df['colB']], default='NA')
df['colC'] = np.select([df['key'] == 'key3'], [df['colC']], default='NA')

print(df)

输出结果：

    key     colA     colB     colC     colD
0  key1  value1A       NA       NA  value1D
1  key2       NA  value2B       NA       NA
2  key3       NA       NA  value3C       NA
3  key1  value4A       NA       NA  value4D
4  key2       NA  value5B       NA       NA

这种方法对于少量列尚可接受，但当需要映射的列增多时，代码的维护性和可读性会迅速下降。因此，寻求更高效、更具向量化的解决方案是至关重要的。

方法一：利用布尔掩码进行高效条件替换 (pd.get_dummies 和 df.mask)

这种方法的核心思想是构建一个与原始DataFrame形状相同的布尔掩码，该掩码指示每个单元格是否应该保留其原始值（True）或被替换为默认值（False）。然后，利用DataFrame.mask()方法根据这个掩码进行批量替换。

实现步骤：

1. 定义键与目标列的映射关系： 创建一个字典，其中键是key列的唯一值，值是与该键关联的目标列名列表。
2. 生成列有效性布尔表： 将映射字典转换为Pandas Series，并使用explode()将其展平。然后，利用pd.get_dummies()创建独热编码，这将为每个键和其对应的有效列生成一个布尔值（True表示有效）。groupby(level=0).max()用于处理explode可能产生的重复键，确保每个键对应一个唯一的列有效性行。
3. 对齐掩码到DataFrame行： 使用mask.reindex(df['key'])根据原始DataFrame的key列，将生成的列有效性布尔表与DataFrame的每一行对齐。.to_numpy()将其转换为NumPy数组，以便后续的向量化操作。
4. 应用掩码进行替换： 选择除了key列之外的所有目标列，然后使用df[cols].mask(condition, other='NA')方法。mask方法会在condition为False的位置替换为other指定的值。

代码示例：

import pandas as pd
import numpy as np

# 创建示例DataFrame
data = {
    'key': ['key1', 'key2', 'key3', 'key1', 'key2'],
    'colA': ['value1A', 'value2A', 'value3A', 'value4A', 'value5A'],
    'colB': ['value1B', 'value2B', 'value3B', 'value4B', 'value5B'],
    'colC': ['value1C', 'value2C', 'value3C', 'value4C', 'value5C'],
    'colD': ['value1D', 'value2D', 'value3D', 'value4D', 'value5D']
}
df = pd.DataFrame(data)

# 1. 定义键与目标列的映射关系
d = {'key1': ['colA', 'colD'],
     'key2': ['colB'],
     'key3': ['colC'],
    }

# 2. 生成列有效性布尔表
# 将字典转换为Series并展平
s = pd.Series(d).explode()
# 使用get_dummies创建独热编码，表示每个key对应的有效列
# groupby(level=0).max()确保每个key只有一行，且True表示该列对该key有效
mask_df = pd.get_dummies(s, dtype=bool).groupby(level=0).max()

# 3. 获取所有需要处理的目标列
cols_to_map = df.columns.difference(['key'])

# 4. 对齐掩码到DataFrame行，并应用到目标列
# mask_df.reindex(df['key']) 根据df['key']的顺序重新索引mask_df
# .to_numpy() 将结果转换为NumPy数组，以便与df[cols_to_map]进行元素级操作
row_level_mask = mask_df.reindex(df['key']).to_numpy()

# 使用mask方法，当row_level_mask为False时，将对应位置的值替换为'NA'
df[cols_to_map] = df[cols_to_map].mask(~row_level_mask, 'NA') # 注意这里使用 ~ 进行布尔反转

print(df)

输出结果：

    key     colA     colB     colC     colD
0  key1  value1A       NA       NA  value1D
1  key2       NA  value2B       NA       NA
2  key3       NA       NA  value3C       NA
3  key1  value4A       NA       NA  value4D
4  key2       NA  value5B       NA       NA

中间结果解释：

• mask_df (列有效性布尔表):

         colA   colB   colC   colD
  key1   True  False  False   True
  key2  False   True  False  False
  key3  False  False   True  False

  这表示key1关联colA和colD，key2关联colB，key3关联colC。

• row_level_mask (mask_df.reindex(df['key']).to_numpy()):

  [[ True False False  True]  # for df['key'] == 'key1'
   [False  True False False]  # for df['key'] == 'key2'
   [False False  True False]  # for df['key'] == 'key3'
   [ True False False  True]  # for df['key'] == 'key1'
   [False  True False False]] # for df['key'] == 'key2'

  这个NumPy数组是最终用于mask操作的布尔掩码，它与df[cols_to_map]的形状完全匹配，True表示对应位置的值应保留，False表示应被替换。

方法二：数据重塑与过滤 (melt, merge, unstack)

第二种方法通过数据重塑（将宽格式转换为长格式，再转换回宽格式）来解决问题。它将原始数据“融化”成一个长格式表，其中每一行代表一个具体的单元格值，然后通过合并操作筛选出有效的键-列组合，最后“堆叠”回宽格式。

实现步骤：

1. 定义键与目标列的映射关系： 同方法一，创建一个字典d。
2. 数据融化 (Melt)： 使用df.reset_index().melt()将DataFrame从宽格式转换为长格式。id_vars参数指定哪些列作为标识符列（index和key），其他列则被“融化”到variable和value列中。
3. 创建映射DataFrame： 将映射字典d转换为一个包含key和variable（列名）的DataFrame。
4. 合并与过滤 (Merge)： 将融化后的DataFrame与映射DataFrame进行内连接（merge）。只有在映射表中存在的key-variable组合及其对应的值才会被保留。
5. 数据堆叠 (Unstack)： 将合并后的结果通过set_index和unstack('variable')操作，从长格式重新堆叠回宽格式。fill_value='NA'参数用于填充那些在合并后没有匹配到值的单元格。
6. 清理索引和列名： 调整索引和列名，使其与原始DataFrame的期望输出一致。

代码示例：

import pandas as pd
import numpy as np

# 创建示例DataFrame
data = {
    'key': ['key1', 'key2', 'key3', 'key1', 'key2'],
    'colA': ['value1A', 'value2A', 'value3A', 'value4A', 'value5A'],
    'colB': ['value1B', 'value2B', 'value3B', 'value4B', 'value5B'],
    'colC': ['value1C', 'value2C', 'value3C', 'value4C', 'value5C'],
    'colD': ['value1D', 'value2D', 'value3D', 'value4D', 'value5D']
}
df = pd.DataFrame(data)

# 1. 定义键与目标列的映射关系
d = {'key1': ['colA', 'colD'],
     'key2': ['colB'],
     'key3': ['colC'],
    }

# 2. 融化DataFrame，保留原始索引和key列
melted_df = df.reset_index().melt(['index', 'key'])

# 3. 从映射字典创建映射DataFrame
# pd.Series(d).explode() 展平映射字典
# .rename_axis('key').reset_index(name='variable') 调整索引和列名
mapping_df = pd.Series(d).explode().rename_axis('key').reset_index(name='variable')

# 4. 合并融化后的DataFrame与映射DataFrame，筛选有效组合
merged_df = melted_df.merge(mapping_df)

# 5. 堆叠数据回宽格式，填充未匹配值
final_df = (merged_df
            .set_index(['index', 'key', 'variable'])['value'] # 设置多级索引
            .unstack('variable', fill_value='NA') # 以variable列进行堆叠，未匹配的填充'NA'
            .reset_index('key') # 将key列从索引中移回普通列
            .rename_axis(index=None, columns=None) # 清理索引和列名
           )

# 将原始df的'key'列重新赋值，并确保顺序一致
df_result = df[['key']].copy() # 复制原始key列
df_result = df_result.set_index(final_df.index) # 对齐索引
df_result[final_df.columns.difference(['key'])] = final_df[final_df.columns.difference(['key'])]
df_result = df_result.reindex(columns=df.columns) # 确保列顺序与原始df一致

print(df_result)

输出结果：

    key     colA     colB     colC     colD
0  key1  value1A       NA       NA  value1D
1  key2       NA  value2B       NA       NA
2  key3       NA       NA  value3C       NA
3  key1  value4A       NA       NA  value4D
4  key2       NA  value5B       NA       NA

注意：在实际应用中，melt、merge、unstack 的链式操作可以更紧凑地写在一起，如问题答案所示。上述代码为了教学目的，拆分了中间步骤。

总结与选择

本教程介绍了两种高效的向量化方法，用于在Pandas DataFrame中根据“键”列的值有条件地映射或填充多个目标列。

1. pd.get_dummies 和 df.mask 方法：

   • 优点： 逻辑直接，通过构建布尔掩码直接进行条件替换，代码相对简洁，易于理解。对于仅需替换不符合条件的值的场景非常高效。
   • 适用场景： 当主要目标是基于键列值，将其他列中不符合条件的数据替换为特定默认值（如'NA'）时。

2. melt, merge, unstack 数据重塑方法：

   • 优点： 具有强大的数据转换能力，不仅限于替换，还可以进行更复杂的筛选、聚合和重构。在处理更复杂的数据依赖关系时，提供了更大的灵活性。
   • 适用场景： 当需要对数据进行更深层次的转换，例如基于键生成新的列结构，或者在筛选过程中需要结合其他条件时。

两种方法都显著优于重复使用numpy.select，尤其是在处理大型数据集时，其向量化特性能够带来显著的性能提升。在选择具体方法时，应根据实际业务需求和代码的清晰度偏好进行权衡。对于简单的条件替换，mask方法可能更直观；而对于复杂的数据重构任务，melt/merge/unstack组合则提供了更强大的工具。

今天关于《DataFrame多列键值映射技巧》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！