如何利用resolve函数高效填充MultiIndex结构的Pandas DataFrame？

假设你已经有了行/列MultiIndex的空DataFrame，以及一个接收行元组、列元组返回字符串的resolve函数，以下是几种比逐元素遍历更高效的实现方式：

方法一：利用笛卡尔积与MultiIndex转Frame #

通过将行/列索引转为DataFrame，生成所有行列元组的笛卡尔积，批量计算值后再转回原结构：

import pandas as pd

# 示例行/列MultiIndex
row_idx = pd.MultiIndex.from_tuples([('A', 1), ('A', 2), ('B', 1)], names=['Level1', 'Level2'])
col_idx = pd.MultiIndex.from_tuples([('X', 'a'), ('X', 'b'), ('Y', 'a')], names=['ColLevel1', 'ColLevel2'])
df = pd.DataFrame(index=row_idx, columns=col_idx)

# 示例resolve函数
def resolve(row_tuple, col_tuple):
    return f"Row:{row_tuple} | Col:{col_tuple}"

# 步骤1：将行/列索引转为DataFrame，添加临时键实现笛卡尔积
row_df = row_idx.to_frame(index=False)
col_df = col_idx.to_frame(index=False)
row_df['key'] = 0
col_df['key'] = 0

# 步骤2：生成所有行列元组配对
pair_df = row_df.merge(col_df, on='key').drop('key', axis=1)
pair_df['row_tuple'] = pair_df[row_idx.names].apply(tuple, axis=1)
pair_df['col_tuple'] = pair_df[col_idx.names].apply(tuple, axis=1)

# 步骤3：批量计算值并转回原结构
pair_df['value'] = pair_df.apply(lambda x: resolve(x['row_tuple'], x['col_tuple']), axis=1)
df = pair_df.set_index(row_idx.names)['value'].unstack(col_idx.names)

方法二：Numpy网格向量化 #

如果resolve函数可以被向量化（或用np.vectorize包装），这种方法效率最高：

import numpy as np

# 将行/列元组转为数组
row_tuples = np.array(row_idx.tuples)
col_tuples = np.array(col_idx.tuples)

# 生成网格，得到每个单元格对应的行/列元组
row_grid, col_grid = np.meshgrid(row_tuples, col_tuples, indexing='ij')

# 向量化resolve函数（若原函数不支持向量化）
vectorized_resolve = np.vectorize(resolve)

# 批量生成值并赋值
df.loc[:, :] = vectorized_resolve(row_grid, col_grid)

方法三：Stack/Unstack配合Apply #

适合结构简单的场景，通过将DataFrame转为Series后批量处理：

# 将DataFrame转为行+列联合索引的Series
stacked = df.stack(list(col_idx.names))

# 提取每个元素对应的行/列元组并计算值
row_name_len = len(row_idx.names)
stacked = stacked.apply(lambda _, idx: resolve(idx[:row_name_len], idx[row_name_len:]), axis=1)

# 转回原MultiIndex结构
df = stacked.unstack(list(col_idx.names))

效率说明 #

以上方法均避免了Python层面的逐元素循环，利用Pandas/Numpy的底层向量化优化，比手动遍历快数倍甚至数十倍，数据量越大优势越明显。

内容的提问来源于stack exchange，提问作者Ted Black