按最大尺寸拆分大型Numpy二维数组

这问题我太懂了——处理十几亿元素的超大Numpy数组时，MemoryError简直是挥之不去的噩梦，尤其是碰到1009这种质数行列数、没法被目标块大小整除的情况，固定拆分数量的方案完全不顶用。我给你一套亲测有效的实现思路，完美适配Python 3.6 64位和Numpy 1.14.3的环境：

核心思路 #

我们不用纠结“拆成多少块”，而是直接按最大允许的块尺寸，计算行列方向的拆分点，确保每个子块的行数≤指定最大行数、列数≤指定最大列数，最后通过切片遍历所有子块，处理后再拼接回原结构。

具体实现代码 #

先上完整的拆分+处理+聚合的示例代码，后面再拆解细节：

import numpy as np

def split_array_into_max_blocks(arr, max_rows, max_cols):
    """
    将Numpy数组拆分为不超过(max_rows, max_cols)尺寸的子块
    返回一个二维列表：blocks[i][j]对应第i行第j列的子块
    """
    rows, cols = arr.shape
    # 计算行方向的拆分点
    row_splits = list(range(0, rows, max_rows))
    if row_splits[-1] != rows:
        row_splits.append(rows)
    # 计算列方向的拆分点
    col_splits = list(range(0, cols, max_cols))
    if col_splits[-1] != cols:
        col_splits.append(cols)
    
    # 遍历拆分点，生成所有子块
    blocks = []
    for i in range(len(row_splits)-1):
        row_start = row_splits[i]
        row_end = row_splits[i+1]
        row_blocks = []
        for j in range(len(col_splits)-1):
            col_start = col_splits[j]
            col_end = col_splits[j+1]
            sub_block = arr[row_start:row_end, col_start:col_end]
            row_blocks.append(sub_block)
        blocks.append(row_blocks)
    return blocks

def aggregate_blocks(blocks):
    """将拆分后的子块重新拼接为原尺寸的数组"""
    # 先按行拼接每一行的子块
    row_arrays = []
    for row_block in blocks:
        row_array = np.hstack(row_block)
        row_arrays.append(row_array)
    # 再垂直拼接所有行数组
    return np.vstack(row_arrays)

# ---------------------- 测试示例 ----------------------
# 生成1009×1009的测试数组（质数行列数）
a = np.random.choice([1,2,3,4], (1009,1009))
# 拆分为不超过50×50的块
blocks = split_array_into_max_blocks(a, max_rows=50, max_cols=50)

# 对每个块执行自定义操作（示例：每个元素加10）
processed_blocks = []
for row_block in blocks:
    processed_row = []
    for sub_block in row_block:
        # 这里替换成你的实际操作
        processed_sub = sub_block + 10
        processed_row.append(processed_sub)
    processed_blocks.append(processed_row)

# 聚合处理后的块
result = aggregate_blocks(processed_blocks)

# 验证结果正确性
assert result.shape == a.shape
assert np.all(result == a + 10)

关键细节解释 #

1. 拆分点计算：

   • 行拆分点用range(0, rows, max_rows)生成，比如1009行的话，会生成[0,50,100,...,1000]，最后手动补全1009，确保最后一个块包含剩余的9行。
   • 列拆分点逻辑完全一致，保证最后一个列块包含剩余的列数。

2. 为什么不用reshape？

   • reshape要求原数组的总元素数能被目标形状整除，而我们的场景是允许非均分拆分，切片的方式更灵活，完全适配任何行列数。

3. 关于memmap的补充：

   • 如果你的数组是从磁盘读取的超大文件，建议结合np.memmap使用——先把数组映射为memmap对象，再用上面的函数拆分，这样能避免一次性把整个数组加载到内存，进一步降低内存压力。

4. 处理和聚合的灵活性：

   • 你可以在遍历子块时执行任何操作（比如数值计算、特征提取等），只要保证处理后的子块形状和原块一致，就能顺利拼接回去。

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