Question

我有一个numpy形状的阵列（64,64,3）。我们怎样才能获得三个维度数组（64,64）。

Answer 1

您可以使用public class ImageProcessor { bool bProcessing; private void getPoints() { } public Action DoImageProcessing; public ImageProcessor() { DoImageProcessing = () => { bProcessing = true; getPoints(); bProcessing = false; }; } }将分割轴一直移到左侧，然后使用序列解包：

moveaxis

Answer 2

这是另一种情况，只需几步，迭代就不错了。

In [145]: arr = np.ones((64,64,3))

解压缩列表解析：

In [146]: a,b,c = [arr[:,:,i] for i in range(3)]
In [147]: a.shape
Out[147]: (64, 64)

解压缩转置数组：

In [148]: a,b,c = np.moveaxis(arr,-1,0)
In [149]: a.shape
Out[149]: (64, 64)

这样一个小例子的计时并不突破，但他们暗示了这两种方法的相对优势：

In [150]: timeit a,b,c = [arr[:,:,i] for i in range(3)]
3.02 µs ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [151]: timeit a,b,c = np.moveaxis(arr,-1,0)
18.4 µs ± 946 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

数组解包（在第一维上）需要将数组转换为3个子数组的列表，这些类似的时序可以看出：

In [154]: timeit a,b,c = list(np.moveaxis(arr,-1,0))
17.8 µs ± 15.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [155]: timeit a,b,c = [i for i in np.moveaxis(arr,-1,0)]
17.9 µs ± 14.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

这不是需要时间的拆包或迭代。这是moveaxis：

In [156]: timeit np.moveaxis(arr,-1,0)
14 µs ± 4.41 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

查看代码后，我们看到它首先从参数构建transpose后使用order：

直接调用transpose很快（因为它只涉及改变形状和步幅）：

In [157]: timeit arr.transpose(2,0,1)
688 ns ± 1.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

解压转码比我原来的列表理解要快一些。

In [158]: timeit a,b,c = arr.transpose(2,0,1)
2.78 µs ± 9.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

因此moveaxis相对于任务的其余部分具有显着的开销。也就是说，它可能不会随着阵列的侧面而增加。这是一个固定的开销。

将3D阵列切割为多个2D阵列

2 个答案: