NumPy - 数组上的迭代

NumPy 包包含一个迭代器对象numpy.nditer。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator接口来访问。

让我们使用arange()函数创建一个 3X4 数组，并使用nditer对它进行迭代。

示例 1

  1. import numpy as np
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '原始数组是：'  
  5. print a print  '\n'  
  6. print  '修改后的数组是：'  
  7. for x in np.nditer(a):  
  8.     print x,

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 修改后的数组是：
  7. 0 5 10 15 20 25 30 35 40 45 50 55

示例 2

迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。

  1. import numpy as np 
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '原始数组是：'  
  5. print a 
  6. print  '\n'  
  7. print  '原始数组的转置是：' 
  8. b = a.T 
  9. print b 
  10. print  '\n'  
  11. print  '修改后的数组是：'  
  12. for x in np.nditer(b):  
  13.     print x,

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 原始数组的转置是：
  7. [[ 0 20 40]
  8.  [ 5 25 45]
  9.  [10 30 50]
  10.  [15 35 55]]
  12. 修改后的数组是：
  13. 0 5 10 15 20 25 30 35 40 45 50 55

迭代顺序

如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。

示例 1

  1. import numpy as np
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '原始数组是：'  
  5. print a print  '\n'  
  6. print  '原始数组的转置是：' 
  7. b = a.T 
  8. print b 
  9. print  '\n'  
  10. print  '以 C 风格顺序排序：' 
  11. c = b.copy(order='C')  
  12. print c for x in np.nditer(c):  
  13.     print x,  
  14. print  '\n'  
  15. print  '以 F 风格顺序排序：' 
  16. c = b.copy(order='F')  
  17. print c 
  18. for x in np.nditer(c):  
  19.     print x,

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 原始数组的转置是：
  7. [[ 0 20 40]
  8.  [ 5 25 45]
  9.  [10 30 50]
  10.  [15 35 55]]
  12. 以 C 风格顺序排序：
  13. [[ 0 20 40]
  14.  [ 5 25 45]
  15.  [10 30 50]
  16.  [15 35 55]]
  17. 0 20 40 5 25 45 10 30 50 15 35 55
  19. 以 F 风格顺序排序：
  20. [[ 0 20 40]
  21.  [ 5 25 45]
  22.  [10 30 50]
  23.  [15 35 55]]
  24. 0 5 10 15 20 25 30 35 40 45 50 55

示例 2

可以通过显式提醒，来强制nditer对象使用某种顺序：

  1. import numpy as np 
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '原始数组是：'  
  5. print a 
  6. print  '\n'  
  7. print  '以 C 风格顺序排序：'  
  8. for x in np.nditer(a, order =  'C'):  
  9.     print x,  
  10. print  '\n'  
  11. print  '以 F 风格顺序排序：'  
  12. for x in np.nditer(a, order =  'F'):  
  13.     print x,

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 以 C 风格顺序排序：
  7. 0 5 10 15 20 25 30 35 40 45 50 55
  9. 以 F 风格顺序排序：
  10. 0 20 40 5 25 45 10 30 50 15 35 55

修改数组的值

nditer对象有另一个可选参数op_flags。 其默认值为只读，但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。

示例

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

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 修改后的数组是：
  7. [[ 0 10 20 30]
  8.  [ 40 50 60 70]
  9.  [ 80 90 100 110]]

外部循环

nditer类的构造器拥有flags参数，它可以接受下列值：

序号 参数及描述
1. c_index 可以跟踪 C 顺序的索引
2. f_index 可以跟踪 Fortran 顺序的索引
3. multi-index 每次迭代可以跟踪一种索引类型
4. external_loop 给出的值是具有多个值的一维数组，而不是零维数组

示例

在下面的示例中，迭代器遍历对应于每列的一维数组。

  1. import numpy as np 
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '原始数组是：'  
  5. print a 
  6. print  '\n'  
  7. print  '修改后的数组是：'  
  8. for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
  9.     print x,

输出如下：

  1. 原始数组是：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 修改后的数组是：
  7. [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]

广播迭代

如果两个数组是可广播的，nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器（数组b被广播到a的大小）。

示例

  1. import numpy as np 
  2. a = np.arange(0,60,5) 
  3. a = a.reshape(3,4)  
  4. print  '第一个数组：'  
  5. print a 
  6. print  '\n'  
  7. print  '第二个数组：' 
  8. b = np.array([1,  2,  3,  4], dtype =  int)  
  9. print b 
  10. print  '\n'  
  11. print  '修改后的数组是：'  
  12. for x,y in np.nditer([a,b]):  
  13.     print  "%d:%d"  %  (x,y),

输出如下：

  1. 第一个数组：
  2. [[ 0 5 10 15]
  3.  [20 25 30 35]
  4.  [40 45 50 55]]
  6. 第二个数组：
  7. [1 2 3 4]
  9. 修改后的数组是：
  10. 0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4