如何高效用4个最近邻中位数替换大数组元素（排除自身）

Hey there! Let's break down why your scipy median filter approach didn't work, and then build a fast, vectorized solution that fits your needs perfectly—no slow loops required.

Why the Scipy Approach Failed #

Your median_filter call used a footprint [1,1,0,1,1] with mode='wrap', which has two key issues for your use case:

1. The wrap mode pulls values from the end of the array for edge positions, which doesn't align with your goal of using only immediate adjacent neighbors.
2. Even for middle positions, the filter's window logic (combined with wrap mode) doesn't strictly select the 2 left and 2 right neighbors you need, leading to the unexpected output you saw.

Fast Vectorized Solution Using Numpy #

We'll use numpy's sliding window tools to efficiently extract the exact 4 neighbors for each middle element, then compute medians in bulk. This approach is fully vectorized, so it's blazingly fast even for massive arrays.

Here's the step-by-step code:

import numpy as np

# Your original array
A = np.array([1,2,3,4,5,6,7,8])

# Step 1: Create sliding windows of size 5 (covers 2 left, current element, 2 right)
windows = np.lib.stride_tricks.sliding_window_view(A, window_shape=5)

# Step 2: Remove the middle element from each window (exclude the value itself)
neighbors = np.delete(windows, 2, axis=1)

# Step 3: Compute the median for each set of neighbors
middle_medians = np.median(neighbors, axis=1)

# Step 4: Build the final array B
B = np.zeros_like(A, dtype=np.float64)

# Assign valid medians to middle positions (indices 2 to len(A)-3)
start_idx = 2
end_idx = len(A) - 2
B[start_idx:end_idx] = middle_medians

# Fill edge positions with any value (you said you don't care about these)
B[[0, 1, len(A)-2, len(A)-1]] = np.nan

Verify the Result #

For your example array A = [1,2,3,4,5,6,7,8], this code produces:

B = [nan, nan, 3.0, 4.0, 5.0, 6.0, nan, nan]

Which matches your expected B[2] = 3, and all middle values follow your neighbor-selection rule perfectly.

For Older Numpy Versions #

If you're using numpy < 1.20 (where sliding_window_view doesn't exist), use this safe alternative with as_strided:

def sliding_window(arr, window_size):
    shape = arr.shape[:-1] + (arr.shape[-1] - window_size + 1, window_size)
    strides = arr.strides + (arr.strides[-1],)
    return np.lib.stride_tricks.as_strided(arr, shape=shape, strides=strides)

windows = sliding_window(A, 5)

Then proceed with the same neighbor removal and median calculation steps.

This solution avoids all Python-level loops, leveraging numpy's optimized backend to handle even the largest arrays efficiently.

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