如何用Pandas方法将目标单元格替换为邻接单元格并生成对应数据集列表

需求概述 #

现有初始DataFrame，需完成以下操作：

• 随机选取占数据集规模10%以内的目标单元格（以(x,y)坐标表示）
• 为每个目标单元格随机选取1-4个上下左右邻接单元格（(x-1,y)、(x,y-1)、(x+1,y)、(x,y+1)）
• 生成所有可能的修改组合对应的DataFrame：每个组合中，目标单元格被替换为选中的邻接单元格的值

原实现依赖大量Python循环和逐单元格操作，效率低下，以下是基于Pandas/Numpy原生向量化操作的优化方案。

优化后的实现代码 #

import pandas as pd
import numpy as np

def create_zipf_distribution():
    zipf_dist = np.random.zipf(2, size=(50, 5))
    return pd.DataFrame(zipf_dist).round(3)

def generate_target_cells(df, num_targets):
    # 确保目标单元格不超过数据集的10%
    max_targets = int(df.shape[0] * df.shape[1] * 0.1)
    num_targets = min(num_targets, max_targets)
    
    # 随机生成不重复的目标单元格坐标（x为列索引，y为行索引）
    x_coords = np.random.randint(0, df.shape[1], size=num_targets)
    y_coords = np.random.randint(0, df.shape[0], size=num_targets)
    
    # 去重（避免重复选中同一单元格）
    target_cells = np.unique(np.column_stack((x_coords, y_coords)), axis=0)
    return target_cells

def generate_neighbor_options(target_cells, df_shape):
    # 定义四个方向的偏移量
    directions = np.array([[0, 1], [1, 0], [0, -1], [-1, 0]])
    neighbor_options = []
    
    for x, y in target_cells:
        # 计算所有邻接单元格坐标
        neighbors = np.array([x, y]) + directions
        # 过滤掉超出DataFrame边界的单元格
        valid_neighbors = neighbors[
            (neighbors[:, 0] >= 0) & (neighbors[:, 0] < df_shape[1]) &
            (neighbors[:, 1] >= 0) & (neighbors[:, 1] < df_shape[0])
        ]
        # 随机选取1-4个有效邻接单元格，包含原目标单元格
        num_selected = np.random.randint(1, min(len(valid_neighbors)+1, 5))
        selected = valid_neighbors[np.random.choice(len(valid_neighbors), num_selected, replace=False)]
        # 组合原目标单元格和选中的邻接单元格
        neighbor_options.append(np.vstack([[x, y], selected]))
    
    return neighbor_options

def generate_all_datasets(df, neighbor_options):
    # 获取所有目标单元格的原始坐标
    target_coords = np.array([opts[0] for opts in neighbor_options])
    # 生成所有可能的替换组合：每个目标单元格选一个替换源
    all_combinations = np.array(np.meshgrid(*[range(len(opts)) for opts in neighbor_options])).T.reshape(-1, len(neighbor_options))
    
    # 获取原始DataFrame的numpy数组副本，用于批量修改
    df_np = df.to_numpy(copy=True)
    
    # 批量生成所有修改后的数据集
    datasets = []
    for combo in all_combinations:
        # 创建数组副本
        new_df_np = df_np.copy()
        # 遍历每个目标单元格，替换为选中的邻接值
        for idx, (opt_idx, target) in enumerate(zip(combo, target_coords)):
            x_src, y_src = neighbor_options[idx][opt_idx]
            new_df_np[target[1], target[0]] = df_np[y_src, x_src]
        # 转换为DataFrame并保留原索引和列名
        datasets.append(pd.DataFrame(new_df_np, columns=df.columns, index=df.index))
    
    return datasets

def main():
    zipf_dataset = create_zipf_distribution()
    target_cells = generate_target_cells(zipf_dataset, 5)
    print("目标单元格坐标：", target_cells)
    
    neighbor_options = generate_neighbor_options(target_cells, zipf_dataset.shape)
    print("每个目标的可选替换源：", neighbor_options)
    
    datasets = generate_all_datasets(zipf_dataset, neighbor_options)
    print(f"生成数据集数量：{len(datasets)}")
    # 可查看第一个数据集的修改效果
    # print(datasets[0].head())

if __name__ == "__main__":
    main()

核心优化点 #

1. 向量化生成目标单元格：用Numpy一次性生成随机坐标并去重，替代原循环逐个生成的逻辑，减少Python层级循环开销。
2. 批量处理邻接单元格：用Numpy广播计算所有方向偏移，结合布尔索引过滤边界无效单元格，高效筛选有效邻接项，同时新增边界校验避免索引错误。
3. 批量生成数据集：基于Numpy数组操作替代Pandas逐单元格修改，减少DataFrame复制开销；利用meshgrid生成所有替换组合，避免嵌套循环处理笛卡尔积。
4. 资源控制：新增目标单元格数量上限控制，确保占比不超过数据集的10%。

内容的提问来源于stack exchange，提问作者marc nicole