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,

巴特西

8、numpy——数组的迭代

1、单数组的迭代

1.1 默认迭代顺序

1.2 控制迭代的顺序

1.3 修改数组中的元素

2、数组迭代(Iterating over arrays)

2.1 使用外部循环 external_loop

2.2 追踪单个索引或多重索引

2.3 广播迭代

最新文章

热门文章