Python 如何并行化阵列创建？

我有以下算法：

迭代二维数组中的所有行：

对于每个处理过的行，我得到1d数组

用处理过的一维数组替换其他二维数组的第i行

我想并行化进程，因为每一行进程都是独立的

我的代码：

def update_grid_row(self, grid, new_neighbours_grid, y):
    grid_row = np.zeros(GRID_WIDTH + 2)
    for x in range(0, GRID_WIDTH):
        xy_status = self.get_status_grid(x, y, grid, new_neighbours_grid)
        grid_row[x + 1] = xy_status

    return grid_row

def get_status_grid(self, x, y, new_grid, new_neighbours_grid):
    current_status = new_grid[x + 1][y + 1]
    living_neighbours = new_neighbours_grid[x][y]

    if living_neighbours < 2 or living_neighbours > 3:
        return int(0)
    elif current_status == 0 and living_neighbours == 3:
        return int(1)
    else:
        return current_status

def run  
    original_grid = self.grid
    new_grid = original_grid
    new_neighbours_grid = self.get_neighbours_grid(new_grid)
    for y in range(0, GRID_HEIGHT):
        grid_row = self.update_grid_row(original_grid, new_neighbours_grid, y)
        new_grid[:, y + 1] = grid_row.T
    self.grid = new_grid

def update_grid_行（self、grid、new_neights_grid、y）：
网格行=np.零（网格宽度+2）
对于范围内的x（0，网格宽度）：
xy\u status=self.get\u status\u grid（x，y，grid，new\u grid）
网格_行[x+1]=xy_状态
返回网格行
def get_status_grid（自我、x、y、新_grid、新_grid）：
当前状态=新网格[x+1][y+1]
生活邻居=新邻居网格[x][y]
如果居住邻居<2或居住邻居>3：
返回整数（0）
elif当前状态==0，居住邻居==3：
返回整数（1）
其他：
返回当前状态
def运行
原始网格=self.grid
新网格=原始网格
新邻居网格=自。获取邻居网格（新网格）
对于范围内的y（0，栅格高度）：
grid\u row=self.update\u grid\u row（原始网格、新网格、y）
新网格[：，y+1]=网格行.T
self.grid=新网格

正如注释中所指出的，多处理可能没有用处，但请注意，您的邻居计数对应于将网格与数组卷积

1 1 1
1 0 1
1 1 1

---

因此，使用

scipy.signal.convalve2d

将为您购买10到100的因子。

您的问题中缺少一些重要的细节。首先，什么是处理每一行并生成1D数组？处理的本质是什么？它是计算范围吗？这些行和数组有多大？@martineau认为这并不重要，我编辑了代码并添加了处理函数。阵列是一个200x150的整数，但它可能会增加到大约4000x4000。您可能不会从多处理中获得太多性能，我的建议是在numpyI中执行所有处理，并同意@Francisco-使用多处理的开销很可能会压倒使用它来解决此问题所获得的任何性能。正如@FranciscoCouzo所建议的，我使用numpy更改了get status网格以处理整行而不处理for循环。where（条件，真值，假值）。这将更新过程加快了10倍。谢谢提示。