迭代 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)

時間上有很大的跳躍，以至於它開始淹沒迭代差異。 我希望在此之上寫入文件，迭代差異幾乎會消失。