numpy 数组迭代Iterating over arrays

在numpy 1.6中引入的迭代器对象nditer提供了许多灵活的方式来以系统的方式访问一个或多个数组的所有元素。

1 单数组迭代

该部分位于numpy-ref-1.14.5第1.15 部分Single Array Iteration。

利用nditer对象可以实现完成访问数组中的每一个元素这项最基本的功能，使用标准的python迭代器接口可以逐个访问每一个元素。

1.1 默认迭代顺序

a = np.arange(6).reshape(2,3)
b = a.T
print(a)
# [[0 1 2]
#  [3 4 5]]
for i in np.nditer(a):
    print(i)
# 1 2 3 4 5 6(节约版面，竖着 -> 横着)
print(b)
# [[0 3]
#  [1 4]
#  [2 5]]
for j in np.nditer(b):
    print(j)
# 1 2 3 4 5 6(节约版面，竖着 -> 横着)

 

注意：通过该种方式迭代输出的是以元素在存储器中的布局顺序输出的，无论其视图做何种改变（转置，变换shape），其输出结果是一致的，该中方式可以提高迭代效率

1.2 控制迭代顺序 Controlling Iteration Order

有时候我们不去考虑元素在存储器中的位置关系，而需要按照特定顺序（如视图顺序）访问数组中的元素，nditer对象提供了一个命令参数来控制迭代输出顺序；

nditer 默认是‘K'，也即order = ’K‘，该默认值为按在存储器中的顺序输出（keep the existing order），默认迭代顺序。

同时 nditer 中还提供了两个参数以控制迭代器输出顺序

- order = ‘ C ’ 按行访问，

for x in np.nditer(a.T, order='C')

等价于

for x in np.nditer(a.T.copy(order='C'))

- order = ' F ' 按列访问，

for x in np.nditer(a.T, order='F')

等价于

for x in np.nditer(a.T.copy(order='F'))

注意：虽然等价，当时其原理是不一样的，

（1）A和A.T的元素以相同的顺序遍历，即它们存储在存储器中的顺序，而A.T.拷贝的元素（order＝‘C’）以不同的顺序被访问，因为它们被放入不同的存储器布局中。

（2）order = ’C‘ / ’F‘ 只是输出顺序改变了。

1.3 修改数组值（Modify Array Values）

一般情况下，python中的常规赋值只需要更变本地变量或全局变量字典中的引用，而不必修改现有变量。

默认情况下，nditer对象将输入数组视为只读对象，要修改数组中的元素，必须指定读写read-write 或只写write-only 模式，这是用每个操作数标志（per-operand flags ）来控制的。

a = np.arange(6).reshape(2,3)
print(a)
# [[0 1 2]
#  [3 4 5]]
for x in np.nditer(a ,op_flags=['readwrite']):
    x[...] = 2 * x
print(a)
# [[ 0  2  4]
#  [ 6  8 10]]

如果不添加 op_flags=['readwrite'] ，则 ValueError: assignment destination is read-only ，所以必须添加readwrite；

一般是从数组元素中引用x，将其转换为所赋值的引用，而不会再将所赋值放入数组元素中；可以简单理解为可以从数组中取出元素并对元素值进行赋值运算，但是不能将计算后的值再放入数组中，如果要实现修改数组中的元素，x应该用省略号索引

注意：

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

for i in np.nditer(a ,op_flags=['readwrite']):
    i = i * 2
print(a)  #a值不发生改变
# [[0 1 2]
#  [3 4 5]]

for j in np.nditer(a ,op_flags=['readwrite']):
    j *= 2
print(a)  #a值均*2
# [[ 0  2  4]
#  [ 6  8 10]]

疑惑：按照语法规则，i = i *2 等价于 i *=2 ，为什么结果却不一样！有知道的请留言说一下，谢谢！

参考：python nditer---迭代数组

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]

面试题：面试题：将矩阵旋转90度，这道题写完之后，非常有成就感！

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

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的大小）

a = np.arange(0,60,5).reshape(3,4)
print(a)
# [[ 0  5 10 15]
#  [20 25 30 35]
#  [40 45 50 55]]
b = np.array([1,  2,  3,  4], dtype = int)
print(b)
# [1 2 3 4]
for x,y in np.nditer([a,b]):
    print("%d:%d" %(x,y))
# 0:1
# # 5:2
# # 10:3
# # 15:4
# # 20:1
# # 25:2
# # 30:3
# # 35:4
# # 40:1
# # 45:2
# # 50:3
# # 55:4

参考：NumPy - 数组上的迭代、nditer —— numpy.ndarray 多维数组的迭代、python nditer---迭代数组、numpy-ref-1.14.5官方文档（1.5 Iterating Over Arrays ）。