如何用NumPy/Pandas高效定位多维数组中任意排列的一维数组？

针对大尺寸数组（10000×12000+）和自定义形状模式（如L形），核心思路是用矢量化操作替代循环+预筛选减少计算量，避免逐元素检查的低效方案。以下是具体实现步骤：

1. 定义模式的相对坐标与对应值 #

先把自定义模式（如L形的[6,7,5,8]）转换成「基准点相对偏移」和「对应值」的配对，基准点可选模式的左上角元素位置：

import numpy as np

# 目标模式值
pattern_values = np.array([6, 7, 5, 8])
# 每个值相对于基准点（第一个元素位置）的坐标偏移 (行偏移, 列偏移)
pattern_offsets = np.array([[0, 0], [0, 1], [1, 1], [2, 1]])

2. 批量生成有效候选基准点 #

根据模式的最大偏移，计算大数组中所有可能的基准点范围（避免越界）：

# 获取模式的最大行/列偏移
max_row_offset = pattern_offsets[:, 0].max()
max_col_offset = pattern_offsets[:, 1].max()

big_array = np.random.randint(0, 10, (10000, 12000))  # 示例大数组，替换为你的实际数组

# 生成所有合法基准点的网格坐标
valid_base_rows = np.arange(big_array.shape[0] - max_row_offset)
valid_base_cols = np.arange(big_array.shape[1] - max_col_offset)
base_rows, base_cols = np.meshgrid(valid_base_rows, valid_base_cols, indexing='ij')

3. 矢量化验证所有候选模式 #

利用NumPy广播特性，一次性提取所有候选区域的数值并与模式对比，避免循环：

# 计算所有候选位置的绝对坐标：基准点 + 偏移
candidate_coords = np.stack([
    base_rows[..., None] + pattern_offsets[:, 0],
    base_cols[..., None] + pattern_offsets[:, 1]
], axis=-1)

# 提取对应位置的数值
candidate_values = big_array[candidate_coords[..., 0], candidate_coords[..., 1]]

# 验证每个候选是否完全匹配模式
matches = np.all(candidate_values == pattern_values, axis=-1)

# 获取所有匹配的基准点坐标
match_base_rows, match_base_cols = np.where(matches)

# 若需要模式所有元素的实际坐标，可通过基准点+偏移计算
all_match_coords = np.stack([
    match_base_rows[:, None] + pattern_offsets[:, 0],
    match_base_cols[:, None] + pattern_offsets[:, 1]
], axis=-1)

4. 大尺寸数组的性能优化 #

针对10000×12000级别的数组，直接全量计算可能内存压力大，可通过以下方式优化：

预筛选减少候选数量 #

先定位模式中出现频率最低的元素，只在该元素的附近（模式偏移范围内）验证，大幅缩小计算范围：

# 选择模式中最罕见的元素（比如示例中的8）
rare_value = 8
# 找到所有该元素的位置
rare_pos_rows, rare_pos_cols = np.where(big_array == rare_value)

# 计算对应的基准点（因为8的偏移是(2,1)，所以基准点 = 8的位置 - 偏移）
candidate_base_rows = rare_pos_rows - 2
candidate_base_cols = rare_pos_cols - 1

# 过滤无效基准点（避免越界）
valid_mask = (
    (candidate_base_rows >= 0) & 
    (candidate_base_rows <= big_array.shape[0] - max_row_offset) &
    (candidate_base_cols >= 0) & 
    (candidate_base_cols <= big_array.shape[1] - max_col_offset)
)

# 仅对有效基准点做验证
valid_base_rows = candidate_base_rows[valid_mask]
valid_base_cols = candidate_base_cols[valid_mask]

# 重复第3步的验证逻辑，仅针对这些候选点

分块处理大数组 #

将大数组拆分为多个带重叠区域的小块（重叠区域等于模式的最大偏移），分别处理后合并结果，避免一次性加载全量数据：

def process_chunk(chunk, chunk_row_start, chunk_col_start, pattern_values, pattern_offsets):
    # 对单个块执行匹配逻辑，返回相对于原数组的匹配坐标
    max_row_offset = pattern_offsets[:,0].max()
    max_col_offset = pattern_offsets[:,1].max()
    valid_base_rows = np.arange(chunk.shape[0] - max_row_offset)
    valid_base_cols = np.arange(chunk.shape[1] - max_col_offset)
    base_rows, base_cols = np.meshgrid(valid_base_rows, valid_base_cols, indexing='ij')
    candidate_coords = np.stack([base_rows[...,None]+pattern_offsets[:,0], base_cols[...,None]+pattern_offsets[:,1]], axis=-1)
    candidate_values = chunk[candidate_coords[...,0], candidate_coords[...,1]]
    matches = np.all(candidate_values == pattern_values, axis=-1)
    match_rows, match_cols = np.where(matches)
    # 转换为原数组坐标
    return match_rows + chunk_row_start, match_cols + chunk_col_start

# 分块示例，块大小设为2000×2000，重叠2行1列
chunk_size = 2000
overlap_row = max_row_offset
overlap_col = max_col_offset
all_matches = []

for row_start in range(0, big_array.shape[0], chunk_size - overlap_row):
    row_end = min(row_start + chunk_size, big_array.shape[0])
    for col_start in range(0, big_array.shape[1], chunk_size - overlap_col):
        col_end = min(col_start + chunk_size, big_array.shape[1])
        chunk = big_array[row_start:row_end, col_start:col_end]
        match_rows, match_cols = process_chunk(chunk, row_start, col_start, pattern_values, pattern_offsets)
        all_matches.append((match_rows, match_cols))

# 合并所有匹配结果
final_match_rows = np.concatenate([r for r, _ in all_matches])
final_match_cols = np.concatenate([c for _, c in all_matches])

5. 处理变换后的切块图像 #

对于翻转、旋转、转置后的切块，可预先生成模式的所有变换版本，再分别执行匹配：

def generate_transformed_patterns(pattern_values, pattern_offsets):
    transformed_patterns = []
    max_row = pattern_offsets[:,0].max()
    max_col = pattern_offsets[:,1].max()
    
    # 原始模式
    transformed_patterns.append((pattern_values, pattern_offsets))
    
    # 水平翻转：列偏移取反，值顺序不变
    flipped_h_offsets = pattern_offsets.copy()
    flipped_h_offsets[:,1] = max_col - flipped_h_offsets[:,1]
    transformed_patterns.append((pattern_values, flipped_h_offsets))
    
    # 垂直翻转：行偏移取反，值顺序不变
    flipped_v_offsets = pattern_offsets.copy()
    flipped_v_offsets[:,0] = max_row - flipped_v_offsets[:,0]
    transformed_patterns.append((pattern_values, flipped_v_offsets))
    
    # 旋转90度：坐标转换 (r,c) → (c, max_row - r)，同时调整值顺序（需根据实际旋转后的元素排列对应）
    rotated90_offsets = np.array([[0, max_row], [1, max_row], [1, max_row-1], [1, max_row-2]])
    rotated90_values = np.array([6, 5, 7, 8])  # 对应旋转后的元素顺序
    transformed_patterns.append((rotated90_values, rotated90_offsets))
    
    # 其他变换（如旋转180、270度、转置等）可按需添加
    return transformed_patterns

# 遍历所有变换后的模式执行匹配
all_transformed_matches = []
for pat_vals, pat_offs in generate_transformed_patterns(pattern_values, pattern_offsets):
    # 执行上述匹配逻辑，将结果存入all_transformed_matches
    pass

注意事项 #

• Pandas并不适合此类多维数组的模式匹配任务，NumPy的矢量化操作是效率最优的选择。
• 若内存仍有压力，可结合dask.array进行并行分块处理，进一步提升大数组的处理能力。

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