如何在Python中为DataFrame指定多列批量应用自定义缺失值标记函数？

问题描述 #

我编写了一个自定义函数add_missing_value_flags，可针对DataFrame的单列生成对应的缺失值标记列。目前有20余列需要处理，这些列可通过列名匹配规则species|plant|earth筛选，想知道Python中有没有类似mydf[mydf.columns[mydf.columns.str.contains('species|plant|earth')]].apply...的批量实现方式？

原代码示例 #

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

# 创建示例数据集
iris = load_iris()

df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= iris['feature_names'] + ['target'])
df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)

# 将所有setosa替换为'missing_value'
df = df.applymap(lambda x: 'missing_value' if x == 'setosa' else x)

# 生成缺失值标记的函数
def add_missing_value_flags(mydf, column):
    
    # 生成新列名
    new_col = "missing_" + column
    
    # 识别多种形式的缺失值并生成标记
    mydf[new_col]= np.where(mydf[column] == 'missing_value', True,
                            np.where(mydf[column] == '', True,
                            np.where(mydf[column] == 'N/A', True,  
                            np.where(mydf[column] == 'N\\A', True, 
                            np.where(mydf[column] == 'NA', True,
                            np.where(mydf[column] == 'N.A.', True,
                            np.where(mydf[column] == 'NONE', True,
                            np.where(mydf[column] == '.', True, 
                            np.where(mydf[column].str.len() == 1, True, 
                            np.where(mydf[column] == '..', True, False))))))))))
    
    return(mydf)


# 单列调用示例
add_missing_value_flags(df, 'species')

执行单列函数后的结果 #

sepal length (cm)  sepal width (cm)  ...        species  missing_species
0                  5.1               3.5  ...  missing_value             True
1                  4.9               3.0  ...  missing_value             True
2                  4.7               3.2  ...  missing_value             True
3                  4.6               3.1  ...  missing_value             True
4                  5.0               3.6  ...  missing_value             True
..                 ...               ...  ...            ...              ...
145                6.7               3.0  ...      virginica            False
146                6.3               2.5  ...      virginica            False
147                6.5               3.0  ...      virginica            False
148                6.2               3.4  ...      virginica            False
149                5.9               3.0  ...      virginica            False

批量实现方案 #

1. 循环遍历目标列（推荐） #

直接筛选出符合规则的列，循环调用函数即可，逻辑清晰且效率稳定：

# 筛选需要处理的目标列
target_columns = df.columns[df.columns.str.contains('species|plant|earth')]

# 批量应用函数
for col in target_columns:
    df = add_missing_value_flags(df, col)

2. 优化缺失值判断逻辑 #

原函数的多层np.where嵌套可读性较差，可改用isin方法简化代码，功能完全一致：

def add_missing_value_flags(mydf, column):
    new_col = f"missing_{column}"
    # 定义所有需要识别的缺失值形式
    missing_patterns = {'missing_value', '', 'N/A', 'N\\A', 'NA', 'N.A.', 'NONE', '.', '..'}
    # 组合缺失值判断条件
    missing_mask = mydf[column].isin(missing_patterns) | (mydf[column].str.len() == 1)
    mydf[new_col] = missing_mask
    return mydf

3. 使用apply的实现方式（不推荐） #

如果一定要用apply，可通过列名判断批量处理，但这种方式不如循环直观：

target_columns = df.columns[df.columns.str.contains('species|plant|earth')]

df = df.apply(lambda col: add_missing_value_flags(df, col.name) if col.name in target_columns else col, axis=0)

内容的提问来源于stack exchange，提问作者John Smith