NumPy - 高级索引

如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，我们就能够用它来索引ndarray。高级索引始终返回数据的副本。 与此相反，切片只提供了一个视图。

有两种类型的高级索引：整数和布尔值。

整数索引

这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时，会变得相当直接。

以下示例获取了ndarray对象中每一行指定列的一个元素。 因此，行索引包含所有行号，列索引指定要选择的元素。

示例 1

  1. import numpy as np 
  3. x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
  4. y = x[[0,1,2],  [0,1,0]]  
  5. print y

输出如下：

  1. [1  4  5]

该结果包括数组中(0,0)，(1,1)和(2,0)位置处的元素。

下面的示例获取了 4X3 数组中的每个角处的元素。 行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]。

示例 2

  1. import numpy as np 
  2. x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
  3. print  '我们的数组是：'  
  4. print x 
  5. print  '\n' 
  6. rows = np.array([[0,0],[3,3]]) 
  7. cols = np.array([[0,2],[0,2]]) 
  8. y = x[rows,cols]  
  9. print  '这个数组的每个角处的元素是：'  
  10. print y

输出如下：

  1. 我们的数组是：                                                                 
  2. [[ 0  1  2]                                                                   
  3.  [ 3  4  5]                                                                   
  4.  [ 6  7  8]                                                                   
  5.  [ 9 10 11]]
  7. 这个数组的每个角处的元素是：                                      
  8. [[ 0  2]                                                                      
  9.  [ 9 11]]

返回的结果是包含每个角元素的ndarray对象。

高级和基本索引可以通过使用切片:或省略号...与索引数组组合。 以下示例使用slice作为列索引和高级索引。 当切片用于两者时，结果是相同的。 但高级索引会导致复制，并且可能有不同的内存布局。

示例 3

  1. import numpy as np 
  2. x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
  3. print  '我们的数组是：'  
  4. print x 
  5. print  '\n'  
  6. # 切片
  7. z = x[1:4,1:3]  
  8. print  '切片之后，我们的数组变为：'  
  9. print z 
  10. print  '\n'  
  11. # 对列使用高级索引 
  12. y = x[1:4,[1,2]] 
  13. print  '对列使用高级索引来切片：'  
  14. print y

输出如下：

  1. 我们的数组是：
  2. [[ 0  1  2] 
  3.  [ 3  4  5] 
  4.  [ 6  7  8]
  5.  [ 9 10 11]]
  7. 切片之后，我们的数组变为：
  8. [[ 4  5]
  9.  [ 7  8]
  10.  [10 11]]
  12. 对列使用高级索引来切片：
  13. [[ 4  5]
  14.  [ 7  8]
  15.  [10 11]]

布尔索引

当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引。

示例 1

这个例子中，大于 5 的元素会作为布尔索引的结果返回。

  1. import numpy as np 
  2. x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
  3. print  '我们的数组是：'  
  4. print x 
  5. print  '\n'  
  6. # 现在我们会打印出大于 5 的元素  
  7. print  '大于 5 的元素是：'  
  8. print x[x >  5]

输出如下：

  1. 我们的数组是：
  2. [[ 0  1  2] 
  3.  [ 3  4  5] 
  4.  [ 6  7  8] 
  5.  [ 9 10 11]] 
  7. 大于 5 的元素是：
  8. [ 6  7  8  9 10 11]

示例 2

这个例子使用了~（取补运算符）来过滤NaN。

  1. import numpy as np 
  2. a = np.array([np.nan,  1,2,np.nan,3,4,5])  
  3. print a[~np.isnan(a)]

输出如下：

  1. [ 1.   2.   3.   4.   5.]

示例 3

以下示例显示如何从数组中过滤掉非复数元素。

  1. import numpy as np 
  2. a = np.array([1,  2+6j,  5,  3.5+5j])  
  3. print a[np.iscomplex(a)]

输出如下：

  1. [2.0+6.j  3.5+5.j]