如何在Numpy中实现重复行内存共享并兼容Numpy函数？

针对你的需求——让NumPy数组中的重复行共享内存，同时保持对NumPy内置函数的兼容性，这里有几个实用方案，既不用从零编写复杂对象，也能避开稀疏矩阵的低效问题：

方案1：利用步长技巧（Stride Tricks）构建共享内存数组 #

这个方法直接通过调整NumPy数组的步长参数，让重复行指向同一块内存区域，完全基于NumPy内置功能，兼容性拉满。

步骤示例 #

import numpy as np

# 你的原始数组
original_arr = np.array([[0,0,0,0], [1,2,3,4], [0,0,0,0], [3,4,5,6]])

# 提取唯一行和对应的索引映射
unique_rows, row_indices = np.unique(original_arr, axis=0, return_inverse=True)
# unique_rows: [[0 0 0 0], [1 2 3 4], [3 4 5 6]]
# row_indices: [0, 1, 0, 2]

# 构建共享内存数组：通过设置行步长为0，让重复索引的行指向同一内存块
strides = (0, unique_rows.strides[1])
shared_arr = np.lib.stride_tricks.as_strided(
    unique_rows[row_indices[0]],
    shape=original_arr.shape,
    strides=strides,
    # 可选：如果不需要修改数组，加上writeable=False更安全
    # writeable=False
)

验证效果 #

print(shared_arr)
# 输出和原数组完全一致：[[0 0 0 0] [1 2 3 4] [0 0 0 0] [3 4 5 6]]

# 修改共享数组的第一行，第三行会同步变化（因为共享内存）
shared_arr[0, 0] = 99
print(shared_arr)
# 输出：[[99  0  0  0] [ 1  2  3  4] [99  0  0  0] [ 3  4  5  6]]

这个方案轻量高效，适合静态数组（不需要动态调整行结构）的场景。

方案2：自定义NumPy数组子类（更灵活） #

如果需要动态添加重复行、自定义索引逻辑，可以继承np.ndarray实现子类，让它完全兼容NumPy函数，同时共享重复行内存。

示例实现 #

import numpy as np

class SharedRowArray(np.ndarray):
    def __new__(cls, unique_rows, row_indices):
        # 创建共享内存的数组视图
        obj = np.ndarray.__new__(
            cls,
            shape=(len(row_indices), unique_rows.shape[1]),
            dtype=unique_rows.dtype,
            buffer=unique_rows.data,
            strides=(0, unique_rows.strides[1])
        )
        # 保存唯一行和索引映射，方便后续操作
        obj._unique_rows = unique_rows
        obj._row_indices = row_indices
        return obj
    
    def __array__(self, dtype=None):
        # 确保NumPy函数能正确识别并处理该对象
        return np.take(self._unique_rows, self._row_indices, axis=0).view(type=self)

# 使用示例
original_arr = np.array([[0,0,0,0], [1,2,3,4], [0,0,0,0], [3,4,5,6]])
unique_rows, row_indices = np.unique(original_arr, axis=0, return_inverse=True)
shared_arr = SharedRowArray(unique_rows, row_indices)

# 测试NumPy函数兼容性
print(np.mean(shared_arr, axis=1))  # 正常计算每行均值
print(shared_arr + 10)  # 正常执行元素级运算

这个子类支持动态调整行索引，后续可以通过修改_row_indices来改变数组结构，同时始终保持内存共享。

方案对比 #

• 方案1：纯内置功能，代码简洁，适合静态数组场景
• 方案2：灵活性高，支持动态调整，适合需要后续修改数组结构的需求

注意：两种方案的共享内存行都会同步修改，这是内存共享的预期行为；如果需要只读共享，可在创建时添加writeable=False参数。

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