如何使用自定义公式对DataFrame缺失值插值并批量应用

我已经能为单个行计算出插值公式来填充缺失值，现在希望将该方法扩展到整个DataFrame，处理更多缺失值。

单行计算示例 #

import pandas as pd

df = pd.DataFrame({'x': [2.2, 2.32, 2.38], 'y': [4.9644, None, 4.9738], 'z' : [5,4,2]})

# 计算缺失值的公式
missing_value = abs((((df.x[2] - df.x[1]) * (df.y[2] - df.y[0])) - ((df.x[2] - df.x[0]) * df.y[2]))/(df.x[2] - df.x[0]))
# 计算结果为 4.9706

扩展场景示例 #

需要处理包含更多缺失值的DataFrame：

df = pd.DataFrame({'x': [2.2, 2.32, 2.38, 2.45,4.44,3.21,None, 2.45], 
                   'y': [4.9644, None, 4.9738, 4.456,None, 4.356, None, None], 
                   'z' : [5,4,2, 1,1,3,4,5]})

我尝试的代码（存在问题） #

import pandas as pd

# 创建包含x和y列的DataFrame
df = pd.DataFrame({'x': [2.2, 2.32, 2.38], 'y': [4.9644, None, 4.9738]})

# 定义计算y列缺失值的函数
def calculate_y(row):
    x0, x1, x2 = row.iloc[0:2, 'x']
    y0, y1, y2 = row.iloc[0:2, 'y']
    return abs((((x2 - x1) * (y2 - y0)) - ((x2 - x0) * y2)) / (x2 - x0))

# 将函数应用到DataFrame并保存到新列
df['calculated_y'] = df.apply(calculate_y, axis=1)

# 打印DataFrame查看calculated_y列
print(df)

解决方案 #

1. 公式逻辑梳理 #

你的自定义公式本质是基于缺失值位置的**前一个有效(x0,y0)和后一个有效(x2,y2)**计算中间缺失的y值，先简化公式避免冗余：

# 原公式简化后：
calculated_y = abs(y0 - (x2 - x1)*(y2 - y0)/(x2 - x0))

2. 批量填充实现代码 #

要批量应用该公式，需要逐个定位缺失值的前后有效数据对，再计算填充：

import pandas as pd

# 示例DataFrame
df = pd.DataFrame({'x': [2.2, 2.32, 2.38, 2.45,4.44,3.21,None, 2.45], 
                   'y': [4.9644, None, 4.9738, 4.456,None, 4.356, None, None], 
                   'z' : [5,4,2, 1,1,3,4,5]})

def fill_missing_y(df):
    # 复制原数据避免修改原始内容
    df_filled = df.copy()
    # 获取y列所有缺失值的索引
    missing_idx = df_filled[df_filled['y'].isna()].index
    
    for idx in missing_idx:
        # 找当前索引前最近的非缺失x、y
        prev_valid = df_filled.loc[:idx-1, ['x', 'y']].dropna().iloc[-1:] if idx > 0 else None
        # 找当前索引后最近的非缺失x、y
        next_valid = df_filled.loc[idx+1:, ['x', 'y']].dropna().iloc[:1] if idx < len(df_filled)-1 else None
        
        # 仅当前后都有有效数据时执行计算
        if prev_valid is not None and not prev_valid.empty and next_valid is not None and not next_valid.empty:
            x0, y0 = prev_valid['x'].values[0], prev_valid['y'].values[0]
            x1 = df_filled.loc[idx, 'x']
            x2, y2 = next_valid['x'].values[0], next_valid['y'].values[0]
            
            # 避免除以0的异常情况
            if x2 != x0:
                # 应用自定义公式计算
                calculated_y = abs((((x2 - x1) * (y2 - y0)) - ((x2 - x0) * y2)) / (x2 - x0))
                df_filled.loc[idx, 'y'] = calculated_y
    return df_filled

# 执行填充并查看结果
df_result = fill_missing_y(df)
print(df_result)

3. 代码说明 #

• 复制原DataFrame，防止直接修改原始数据
• 遍历所有y列缺失值的索引，逐个匹配前后最近的有效(x,y)数据对
• 仅在前后都有有效数据时计算，同时处理x0=x2的异常（避免除以0）
• 将计算结果填充到对应缺失位置

4. 测试初始小数据集 #

用你最初的测试数据验证，会得到和手动计算一致的结果：

test_df = pd.DataFrame({'x': [2.2, 2.32, 2.38], 'y': [4.9644, None, 4.9738], 'z' : [5,4,2]})
filled_test = fill_missing_y(test_df)
print(filled_test['y'][1]) # 输出4.9706

内容的提问来源于stack exchange，提问作者chuky pedro