相邻元素查表构建高效映射方法

本文揭秘了如何借助 NumPy 的滑动窗口与向量化索引技术，将数组中每列的垂直相邻元素对高效映射为预定义规则下的对应值，全程摒弃低效的 Python 循环——无论是值域紧凑时用稠密二维查找表实现毫秒级转换，还是面对海量稀疏取值时借力 Pandas 的哈希合并大幅节省内存并保持高性能，都为你提供了即开即用、经过实测验证的工业级解决方案，让复杂映射在大数据场景下依然丝滑如初。

本文介绍如何利用 NumPy 的滑动窗口与索引映射技术，将输入数组中每列的相邻行对（vertical pairs）快速映射为预定义规则数组中的对应值，全程避免 Python 循环，实现毫秒级高性能转换。

本文介绍如何利用 NumPy 的滑动窗口与索引映射技术，将输入数组中每列的相邻行对（vertical pairs）快速映射为预定义规则数组中的对应值，全程避免 Python 循环，实现毫秒级高性能转换。

在科学计算与数据处理中，常需根据垂直方向上相邻元素组成的有序对（如 a[i, j] → a[i+1, j]），从一张查找表中提取对应数值。本教程以一个典型场景为例：给定源数组 a（形状为 (n_rows, n_cols)）和规则数组 b（每行形如 [from_val, to_val, mapped_value]），目标是生成结果数组 c（形状为 (n_rows−1, n_cols)），其中 c[i, j] 等于 b 中满足 b[k, 0] == a[i, j] and b[k, 1] == a[i+1, j] 的 b[k, 2]。

核心思路是将规则数组 b 转换为二维查找表（lookup matrix），再用滑动窗口提取所有相邻对，最后通过高级索引一次性完成映射——整个过程完全向量化，无显式循环。

✅ 推荐方案：稠密索引 + sliding_window_view

当 b 中的取值范围紧凑（例如仅含 1~3 或 0~N−1），推荐使用以下高效方法：

import numpy as np
from numpy.lib.stride_tricks import sliding_window_view as swv

# 示例数据
a = np.array([[2, 3, 1, 3],
              [3, 2, 1, 3],
              [1, 1, 1, 2],
              [1, 3, 2, 3],
              [3, 3, 1, 3],
              [2, 1, 3, 2]])

b = np.array([[1, 1, 6],
              [1, 2, 0],
              [1, 3, 9],
              [2, 1, 6],
              [2, 2, 0],
              [2, 3, 4],
              [3, 1, 1],
              [3, 2, 0],
              [3, 3, 8]])

# 步骤 1：构建二维查找表 s，s[i, j] 表示从 i 到 j 的映射值
max_val = b[:, :2].max()
s = np.full((max_val + 1, max_val + 1), -1)  # 填充 -1 表示未定义（可按需设为 0 或 NaN）
s[b[:, 0], b[:, 1]] = b[:, 2]

# 步骤 2：提取 a 中所有垂直相邻对（形状: (n-1, n_cols, 2)）
pairs = swv(a, 2, axis=0)  # 沿行方向滑动，窗口大小为 2

# 步骤 3：批量索引：pairs[..., 0] 和 pairs[..., 1] 分别作为行/列索引
c = s[pairs[..., 0], pairs[..., 1]]

print(c)
# 输出：
# [[4 0 6 8]
#  [1 6 6 0]
#  [6 9 0 4]
#  [9 8 6 8]
#  [0 1 9 0]]

⚠️ 注意事项：

• 若 b 中值从 1 开始（如本例），而 NumPy 数组索引从 0 开始，可统一减 1 后构造更紧凑的 (3, 3) 表（见答案中的 variant）；
• s 中未覆盖的索引组合会返回 -1，建议根据业务逻辑用 np.where(c == -1, default_val, c) 处理缺失映射；
• sliding_window_view 自 NumPy 1.20 起内置，旧版本请升级或手动实现（如 a[:-1] 和 a[1:] 拼接）。

? 备选方案：稀疏索引 + Pandas 合并（适用于大值域）

当 b 的取值跨度极大（如 1~50000，但实际只出现 1000 个值），构建稠密二维表会导致内存爆炸（O(N²)）。此时应改用基于哈希的关联查找：

import pandas as pd

# 将相邻对展平为 DataFrame
pairs_flat = pd.DataFrame(
    swv(a, 2, axis=0).reshape(-1, 2),
    columns=['from', 'to']
)

# 规则表转 DataFrame
rules_df = pd.DataFrame(b, columns=['from', 'to', 'value'])

# 左连接获取映射值，并还原形状
c_flat = pairs_flat.merge(rules_df, on=['from', 'to'], how='left')['value'].to_numpy()
c = c_flat.reshape(-1, a.shape[1])

该方法时间复杂度接近 O(M log M)（M 为相邻对总数），内存占用线性于数据规模，在稀疏场景下比稠密方案快 1000 倍以上（参见原答案性能对比）。

✅ 总结

无论采用哪种方式，都应避免逐列/逐对循环——向量化是大规模重复计算性能的生命线。实际部署前，建议用真实数据规模做 timeit 验证，并结合 cProfile 定位瓶颈。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《相邻元素查表构建高效映射方法》文章吧，也可关注golang学习网公众号了解相关技术文章。