迭代NumPy数组的最快/正确方法

Question

迭代数组的最快方法是什么？已知使用for循环较慢，例如：

>>> for element in the_array: do thing

但是，我有一个大小为(N, 7, 2)数组，需要对每个元素N做一些处理。有时这可能是一个矢量化的计算，所以我知道有一个快速的解决方案；有时它会写入文件。因此，我的直接解决方案是遍历Python range并对数组进行索引：

>>> for i in range(N): file.write(str(list(map(list, the_array[i]))))

有没有更快的方法(或者，如果这是错误的，也许是正确的方法)来迭代数组？

Answer 1

制作样品

In [290]: arr = np.ones((1000,7,2),int) 

一些简单的迭代：

In [303]: timeit list(arr)                                                                       
247 µs ± 1.24 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [304]: timeit [row for row in arr]                                                            
287 µs ± 12.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [305]: timeit [arr[i] for i in range(arr.shape[0])]                                           
325 µs ± 1.65 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

将数组转换为完全到列表：

In [306]: timeit arr.tolist()                                                                    
657 µs ± 30.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [307]: timeit [row.tolist() for row in arr]                                                   
876 µs ± 3.38 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

将该转换移出计时，并在结果列表上迭代：

In [308]: %%timeit alist = arr.tolist() 
     ...: [row for row in alist]                                                                                        
36.9 µs ± 1.51 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

在1000个元素列表上迭代比在数组的第一个维度上迭代要快得多。数组迭代在每一步都必须生成一个新数组，这(相对)慢，即使它是一个view。列表迭代只需引用已存在于内存中的列表元素。

现在将字符串格式添加到任务中：

In [309]: timeit [str(row.tolist()) for row in arr]                                              
3.87 ms ± 113 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)                                                                                        
In [310]: timeit [str(row) for row in arr.tolist()]                                              
3.77 ms ± 275 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In [311]: timeit [str(arr[i].tolist()) for i in range(1000)]                                     
4.07 ms ± 62.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In [312]: %%timeit alist = arr.tolist() 
     ...: [str(row) for row in alist]                                                                                        
3 ms ± 185 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

在时间上有一个很大的跳跃，以至于它开始淹没迭代差异。我希望在此基础上进行文件写入，迭代差异将几乎消失。