8、numpy——數組的迭代

1、單數組的迭代

NumPy 迭代器對象 numpy.nditer 提供了一種靈活訪問一個或者多個數組元素的方式。

迭代器最基本的任務的可以完成對數組元素的訪問。

1.1 默認迭代順序

import numpy as np
a = np.arange(6).reshape(2, 3)
b = a.T  # b為a的裝置
print('a=', a)
for i in np.nditer(a):
    print(i)
print('b=', b)
for i in np.nditer(b):
    print(i)

 

 執行結果：

a= [[0 1 2]
 [3 4 5]]
0
1
2
3
4
5
b= [[0 3]
 [1 4]
 [2 5]]
0
1
2
3
4
5

 

注意：通過該種方式迭代輸出的是以元素在存儲器中的布局順序輸出的，無論其視圖做何種改變（轉置，變換shape），其輸出結果是一致的，該中方式可以提高迭代效率

a 和 a.T 的遍歷順序是一樣的，也就是他們在內存中的存儲順序也是一樣的，但是 a.T.copy(order = 'C') 的遍歷結果是不同的，那是因為它和前兩種的存儲方式是不一樣的，默認是按行訪問。

1.2 控制迭代的順序

• for x in np.nditer(a, order='F'):Fortran order，即是列序優先；

• for x in np.nditer(a.T, order='C'):C order，即是行序優先；

import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始數組是：') 
print (a) 
print ('\n') 
print ('原始數組的轉置是：') 
b = a.T 
print (b) 
print ('\n') 
print ('以 C 風格順序排序：') 
c = b.copy(order='C')  
print (c)
for x in np.nditer(c):  
    print (x, end=", " )
print  ('\n') 
print  ('以 F 風格順序排序：')
c = b.copy(order='F')  
print (c)
for x in np.nditer(c):  
    print (x, end=", " )

 

執行結果：

原始數組是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


原始數組的轉置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]


以 C 風格順序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 

以 F 風格順序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,

 

 

可以通過顯式設置，來強制 nditer 對象使用某種順序：

import numpy as np 
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始數組是：')
print (a)
print ('\n')
print ('以 C 風格順序排序：')
for x in np.nditer(a, order =  'C'):  
    print (x, end=", " )
print ('\n')
print ('以 F 風格順序排序：')
for x in np.nditer(a, order =  'F'):  
    print (x, end=", " )

 

執行結果：

原始數組是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


以 C 風格順序排序：
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 

以 F 風格順序排序：
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 5

 

1.3 修改數組中的元素

nditer 對象有另一個可選參數 op_flags。 默認情況下，nditer 將視待迭代遍歷的數組為只讀對象（read-only），為了在遍歷數組的同時，實現對數組元素值得修改，必須指定 read-write 或者 write-only 的模式。

import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始數組是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print ('修改后的數組是：')
print (a)

 

執行結果：

原始數組是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


修改后的數組是：
[[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

 

2、數組迭代(Iterating over arrays)

該部分內容位於numpy-ref-1.14.5中的3.15.4 Iterating over arrays 章節

numpy.nditer 為高效多維迭代器對象，用於對數組的迭代。

flags：sequence of str ，optional

用於控制迭代器行為的標志（flags）

buffrered - 再需要時可以緩沖

c_index - 跟蹤C順序的索引

f_index - 跟蹤F順序的索引

multi_index - 跟蹤 多指標，或每個迭代維度的一組指數

external_loop - 外部循環，將一維的最內層的循環轉移到外部循環迭代器，使得numpy的矢量操作在處理更大規模數據時變得更有效率。

 

op_flags：list of list of str , optional

這是每個操作數的標志列表。至少必須指定一個“只讀”、“讀寫”或“寫”。

readonly - 該操作數表明可以讀取

readwrite - 該操作數表明可以讀取和寫入

writeonly - 該操作數表明僅寫入

no_broadcast - 該操作數可以防止被廣播

copy - 該操作數表明允許臨時只讀拷貝

 

op_dtypes：dtype or tuple of dtype(s), optional

操作數所需的數據類型（s）。

 

order：{‘C’, ‘F’, ‘A’, ‘K’}, optional

控制迭代順序（Controls the iteration order）

 2.1 使用外部循環 external_loop

將一維的最內層的循環轉移到外部循環迭代器，使得numpy的矢量化操作在處理更大規模數據時變得更有效率。

a = np.arange(6).reshape(2,3)
print(a)
# [[0 1 2]
#  [3 4 5]]
for x in np.nditer(a, flags = ['external_loop']):
    print(x)
# [0 1 2 3 4 5]

for x in np.nditer(a, flags = ['external_loop'],order = 'C'):
    print(x)
# [0 1 2 3 4 5]

for x in np.nditer(a, flags = ['external_loop'],order = 'F'):
    print(x)
# [0 3]
# [1 4]
# [2 5]

2.2 追蹤單個索引或多重索引

a = np.arange(6).reshape(2,3)
print(a)
# [[0 1 2]
#  [3 4 5]]
it = np.nditer(a,flags = ['f_index'])

while not it.finished:
    print("%d <%d>" % (it[0], it.index))
    it.iternext()

# 0 <0>
# 1 <2>
# 2 <4>
# 3 <1>
# 4 <3>
# 5 <5>

為了更清楚地表述，可以直觀地看下表

flags = multi_index

a = np.arange(6).reshape(2,3)
print(a)
# [[0 1 2]
#  [3 4 5]]
it = np.nditer(a,flags = ['multi_index'])

while not it.finished:
    print("%d <%s>" % (it[0], it.multi_index))
    it.iternext()
# 0 <(0, 0)>
# 1 <(0, 1)>
# 2 <(0, 2)>
# 3 <(1, 0)>
# 4 <(1, 1)>
# 5 <(1, 2)>

multi_index是將元素的行列位置以元組方式打印出來，但元組形式不是整型，所以要將 %d 變為 %s，

若不改，則會報錯 TypeError: %d format: a number is required, not tuple 

import numpy as np
a = np.arange(6).reshape(1,2,3)
print(a)
# [[[0 1 2]
#   [3 4 5]]]
it = np.nditer(a,flags = ['multi_index'])

while not it.finished:
    print("%d <%s>" % (it[0], it.multi_index))
    it.iternext()
# 0 <(0, 0, 0)>
# 1 <(0, 0, 1)>
# 2 <(0, 0, 2)>
# 3 <(0, 1, 0)>
# 4 <(0, 1, 1)>
# 5 <(0, 1, 2)>

2.3 廣播迭代

如果兩個數組是 可廣播的，nditer組合對象能夠同時迭代它們，假設數組 a 具有維度 3*4 ，並且存在維度為 1*4的另一個數組b，則使用以下類型的迭代器（數組b被廣播到a的大小）

 

import numpy as np 
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  ('第一個數組為：')
print (a)
print  ('\n')
print ('第二個數組為：')
b = np.array([1,  2,  3,  4], dtype =  int)  
print (b)
print ('\n')
print ('修改后的數組為：')
for x,y in np.nditer([a,b]):  
    print ("%d:%d"  %  (x,y), end=", " )

執行結果：

第一個數組為：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


第二個數組為：
[1 2 3 4]


修改后的數組為：
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,