https://docs.scipy.org/doc/nu…

索引

ndarrays 可以使用标准 Python x[obj]语法对其进行索引，其中 x 是数组，obj是选择方式。有三种可用的索引：字段访问，基本切片，高级索引。究竟是哪一个取决于obj。

注意
在 Python 中，x[(exp1, exp2, ..., expN)]相当于 x[exp1, exp2, ..., expN]; 后者只是前者的语法糖。

基本切片和索引

基本切片 将 Python 的切片基本概念扩展到 N 维。当 obj 是一个 slice 对象（由括号内的 start:stop:step 符号构造）、整数或切片对象和整数的元组时，会发生基本切片。也包括 省略号（三个点）和 newaxis 对象。

从版本 1.15.0 开始不推荐使用：为了保持向后兼容 Numeric 中的常见用法，如果选择对象是包含 slice 对象、省略号，或 newaxis 对象的任何非 nararray 和非元组序列（例如 list），则也会启动基本切片，但不适用于整数数组或其他嵌入序列。

使用 N 个整数进行索引的最简单情况返回表示相应项的数组标量。正如在 Python 中，所有下标是从零开始：对我个索引你，取值范围为 $$ 0 \le n_i < d_i $$ 其中 d_i 是 我的阵列的形状的个元素。负指数被解释为从数组的末尾开始计数（即，如果 n_i <0，则意味着 n_i + d_i）。

基本切片生成的所有数组始终 是原始数组的视图。

序列切片的标准规则适用于基于每维的基本切片（包括使用步骤索引）。要记住的一些有用的概念包括：

基本切片语法是 i:j:k 其中我是起始索引，j 是停止索引，并且ķ是步骤 $$ k \neq 0 $$。这将选择米元件（在对应的尺寸）与索引值我，i,i+k，…，1 +（m – 1）k, 其中 $$ m = q +（r \ neq0）$$ 和 q 和 r 是通过 j -i 除 k 所获得的商和余数: $$ j – i = qk + r $$，因此 $$ i +（m – 1）k <j $$。

例

>>>
>>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> x[1:7:2]
array([1, 3, 5])

负 i 和 j 被解释为 n + i 和 n + j，其中 n 是相应维度中的元素数量。负 k 使得踩踏指向更小的指数。

例

>>>
>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

假设 n 是要切片的维度中的元素数。然后，如果我没有给出其默认值为 0 K> 0 和 N – 1 为ķ<0。如果没有给出 j，则对于 k > 0，默认为 n ; 对于 k <0，默认为 -n-1。如果没有给出 k，则默认为 1. 注意，与此相同，表示沿此轴选择所有索引。:::

例

>>>
>>> x[5:]
array([5, 6, 7, 8, 9])

如果选择元组中的对象数小于 N，则: 假定任何后续维。

例

>>>
>>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
>>> x.shape
(2, 3, 1)
>>> x[1:2]
array([[[4],
        [5],
        [6]]])

Ellipsis 扩展为: 制作与长度相同的选择元组所需的对象数 x.ndim。可能只存在一个省略号。

例

>>>
>>> x[...,0]
array([[1, 2, 3],
       [4, 5, 6]])

newaxis 选择元组中的每个对象用于将所得选择的维度扩展一个单位长度维度。添加的维度是 newaxis 对象在选择元组中的位置。

例

>>>
>>> x[:,np.newaxis,:,:].shape
(2, 1, 3, 1)

整数 i 返回相同的值，i:i+1 除了返回的对象的维度减少 1. 特别是，具有第 p 个元素的整数（和所有其他条目:）的选择元组返回具有维度的相应子数组 N – 1。如果 N = 1，则返回的对象是数组标量。Scalars 中解释了这些对象。

如果选择元组具有: 除作为切片对象的第 p 个条目之外的 所有条目 i:j:k，则返回的数组具有通过连接由元素 i，i + k，…，i + 的整数索引返回的子数组形成的维 N. m – 1）k <j，

: 切片元组中具有多个非条目的基本切片，就像使用单个非: 条目重复应用切片一样，其中: 连续地获取非条目（所有其他非: 条目被替换:）。因此，在基本切片下的 x[ind1,…,ind2,:]行为 xind1。

警告
对于高级索引，上述情况并非如此。

您可以使用切片来设置数组中的值，但是（与列表不同）您永远不会增长数组。要设置的值的大小 必须（可广播）为与其相同的形状。x[obj] = valuex[obj]

注意
请记住，切片元组总是可以构造为 obj 并在 x[obj]符号中使用。可以在构造中使用切片对象来代替 [start:stop:step] 符号。例如，x[1:10:5,::-1] 也可以实现为。这对于构造适用于任意维数组的通用代码非常有用。obj = (slice(1,10,5), slice(None,None,-1)); x[obj]

numpy.newaxis
该 newaxis 对象可用于所有切片操作，以创建长度为 1 的轴。newaxis 是 ’None’ 的别名，’None’ 可以用来代替相同的结果。

高级索引

当选择对象 obj 是非元组序列对象，ndarray（数据类型为整数或 bool）或具有至少一个序列对象或 ndarray（数据类型为 integer 或 bool）的元组时，将触发高级索引。高级索引有两种类型：整数和布尔值。

高级索引始终返回数据的副本（与返回视图的基本切片形成对比）。

警告

高级索引的定义意味着 x[(1,2,3),]根本不同于 x[(1,2,3)]。后者相当于 x[1,2,3]触发基本选择，而前者将触发高级索引。一定要明白为什么会这样。

同时认识到 x[[1,2,3]]将触发高级索引，而由于上面提到的不推荐的数字兼容性，x[[1,2,slice(None)]]将触发基本切片。

整数数组索引

整数数组索引允许根据数组的 N 维索引选择数组中的任意项。每个整数数组表示该维度的许多索引。

纯整数数组索引

当索引包含尽可能多的整数数组时，索引的数组具有维度，索引是直接的，但与切片不同。

高级索引始终作为一个广播和迭代：

result[i_1, ..., i_M] == x[ind_1[i_1, ..., i_M], ind_2[i_1, ..., i_M],
                           ..., ind_N[i_1, ..., i_M]]

请注意，结果形状与（广播）索引数组形状相同。ind_1, …, ind_N

例
从每一行开始，应选择一个特定元素。行索引是 just，列索引指定要为相应行选择的元素。将两者结合使用可以使用高级索引解决任务：0, 1, 2

>>>
>>> x = np.array([[1, 2], [3, 4], [5, 6]])
>>> x[[0, 1, 2], [0, 1, 0]]
array([1, 4, 5])

为了实现类似于上面的基本切片的行为，可以使用广播。该功能 ix_可以帮助这种广播。通过示例可以最好地理解这一点。

例
从 4 ×3 阵列中，应使用高级索引选择角元素。因此，列是其中之一的所有元素和行是需要选择的行。要使用高级索引，需要明确选择所有元素。使用前面解释的方法可以写：0, 2

>>>
>>> x = array([[0,  1,  2],
...            [3,  4,  5],
...            [6,  7,  8],
...            [9, 10, 11]])
>>> rows = np.array([[0, 0],
...                  [3, 3]], dtype=np.intp)
>>> columns = np.array([[0, 2],
...                     [0, 2]], dtype=np.intp)
>>> x[rows, columns]
array([[0,  2],
       [9, 11]])

但是，由于上面的索引数组只是重复自身，因此可以使用广播（比较诸如此类的操作）来简化：rows[:, np.newaxis] + columns

>>>
>>> rows = np.array([0, 3], dtype=np.intp)
>>> columns = np.array([0, 2], dtype=np.intp)
>>> rows[:, np.newaxis]
array([[0],
       [3]])
>>> x[rows[:, np.newaxis], columns]
array([[0,  2],
       [9, 11]])

这种广播也可以使用以下功能实现 ix_：

>>>
>>> x[np.ix_(rows, columns)]
array([[0,  2],
       [9, 11]])

请注意，如果没有 np.ix_调用，只会选择对角线元素，如上例所示。对于使用多个高级索引进行索引，这个差异是最重要的。

结合高级索引和基本索引
当至少有一个 slice（:），省略号（…）或 newaxis 索引（或者数组的维度多于高级索引）时，行为可能会更复杂。这就像连接每个高级索引元素的索引结果一样

在最简单的情况下，只有一个单一的指标先进。单个高级索引可以例如替换切片，并且结果数组将是相同的，但是，它是副本并且可以具有不同的存储器布局。当可能时，切片是优选的。

例

>>>
>>> x[1:2, 1:3]
array([[4, 5]])
>>> x[1:2, [1, 2]]
array([[4, 5]])

了解情况的最简单方法可能是考虑结果形状。索引操作分为两部分，即由基本索引（不包括整数）定义的子空间和来自高级索引部分的子空间。需要区分两种索引组合：

高级索引由切片分隔，Ellipsis 或 newaxis。例如。x[arr1, :, arr2]
高级索引彼此相邻。例如但不是 因为在这方面是一个高级索引。x[…, arr1, arr2, :] x[arr1, :, 1]1
在第一种情况下，高级索引操作产生的维度首先出现在结果数组中，然后是子空间维度。在第二种情况下，高级索引操作的维度将插入到结果数组中与初始数组中相同的位置（后一种逻辑使简单的高级索引行为就像切片一样）。

例
假设 x.shape 为（10,20,30）并且 ind 是（2,3,4）形索引 intp 数组，则其形状为（10,2,3,4,30），因为（20，）形子空间已被替换具有（2,3,4）形的广播索引子空间。如果我们让 i，j，k 循环遍及（2,3,4）形子空间。此示例产生的结果与。result = x[…,ind,:]result[…,i,j,k,:] = x[…,ind[i,j,k],:]x.take(ind, axis=-2)

例
设 x.shape（10,20,30,40,50）并假设 ind_1 并 ind_2 可以广播到形状（2,3,4）。然后 x[:,ind_1,ind_2]具有形状（10,2,3,4,40,50），因为来自 X 的（20,30）形子空间已经被索引的（2,3,4）子空间替换。但是，它 x[:,ind_1,:,ind_2]具有形状（2,3,4,10,30,50），因为在索引子空间中没有明确的位置，所以它在开头就被添加了。始终可以使用 .transpose()在任何需要的位置移动子空间。请注意，此示例无法使用复制 take。

布尔数组索引

当 obj 是布尔类型的数组对象时，会发生此高级索引，例如可能从比较运算符返回。x[obj.nonzero()]如上所述，单个布尔索引数组实际上与 obj.nonzero()返回 obj.ndim 显示 objTrue 元素的整数索引数组的元组（长度）相同。但是，它更快。obj.shape == x.shape

如果，返回一个 1 维数组，该数组填充了与 obj 值对应的 x 元素。搜索顺序为行主，C 风格。如果物镜具有在该外侧是的边界的条目值 X，则索引错误将被提高。如果 obj 小于 x，则与填充它相同。obj.ndim == x.ndimx[obj]TrueTrueFalse

例
一个常见的用例是过滤所需的元素值。例如，可能希望从阵列中选择非 NaN 的所有条目：

>>>
>>> x = np.array([[1., 2.], [np.nan, 3.], [np.nan, np.nan]])
>>> x[~np.isnan(x)]
array([1.,  2.,  3.])

或者希望为所有负面元素添加常量：

>>>
>>> x = np.array([1., -1., -2., 3])
>>> x[x < 0] += 20
>>> x
array([1.,  19.,  18.,   3.])

通常，如果索引包括布尔数组，则结果将与插入 obj.nonzero()相同位置并使用上述整数数组索引机制相同。相当于。x[ind_1, boolean_array, ind_2]x[(ind_1,) + boolean_array.nonzero() + (ind_2,)]

如果只有一个布尔数组且没有整数索引数组，则这是直截了当的。必须注意确保布尔索引具有与其应该使用的维度完全相同的维度。

例
从数组中，选择总和小于或等于 2 的所有行：

>>>
>>> x = np.array([[0, 1], [1, 1], [2, 2]])
>>> rowsum = x.sum(-1)
>>> x[rowsum <= 2, :]
array([[0, 1],
       [1, 1]])

但如果 rowsum 还有两个维度：

>>>
>>> rowsum = x.sum(-1, keepdims=True)
>>> rowsum.shape
(3, 1)
>>> x[rowsum <= 2, :]    # fails
IndexError: too many indices
>>> x[rowsum <= 2]
array([0, 1])

由于额外的维度，最后一个只给出了第一个元素。比较 rowsum.nonzero()以了解此示例。

通过 obj.nonzero()类比可以最好地理解组合多个布尔索引数组或布尔与整数索引数组。该函数 ix_ 还支持布尔数组，并且可以毫无意外地工作。

例
使用布尔索引选择加起来为偶数的所有行。同时，应使用高级整数索引选择列 0 和 2。使用该 ix_功能可以通过以下方式完成：

>>>
>>> x = array([[0,  1,  2],
...            [3,  4,  5],
...            [6,  7,  8],
...            [9, 10, 11]])
>>> rows = (x.sum(-1) % 2) == 0
>>> rows
array([False,  True, False,  True])
>>> columns = [0, 2]
>>> x[np.ix_(rows, columns)]
array([[3,  5],
       [9, 11]])

没有 np.ix_呼叫或只选择对角线元素。

或者没有 np.ix_（比较整数数组示例）：

>>>
>>> rows = rows.nonzero()[0]
>>> x[rows[:, np.newaxis], columns]
array([[3,  5],
       [9, 11]])

详细说明

这些是一些详细的注释，对于日常索引（无特定顺序）并不重要：

本机 NumPy 索引类型 intp 可能与默认的整数数组类型不同。intp 是足以安全索引任何数组的最小数据类型; 对于高级索引，它可能比其他类型更快。
对于高级分配，通常不保证迭代顺序。这意味着如果元素设置不止一次，则无法预测最终结果。
空（元组）索引是零维数组的完整标量索引。如果是零维则 x[()]返回标量，否则返回 x 视图。另一方面，x[…]总是返回一个视图。
如果索引中存在零维数组并且它是完整的整数索引，则结果将是标量而不是零维数组。（不会触发高级索引。）
当存在省略号（…）但没有大小（即替换为零 :）时，结果仍将始终为数组。如果没有高级索引，则为视图，否则为副本。
nonzero 布尔数组的等价性不适用于零维布尔数组。
当高级索引操作的结果没有元素但单个索引超出范围时，是否 IndexError 引发了未定义（例如，超出范围）。x[[], [123]]123
当在赋值期间发生转换错误时（例如，使用字符串序列更新数值数组），被分配的数组可能最终处于不可预测的部分更新状态。但是，如果发生任何其他错误（例如超出范围索引），则阵列将保持不变。
高级索引结果的内存布局针对每个索引操作进行了优化，并且不能假设特定的内存顺序。
当使用一个子类（尤其是其操纵它的形状），默认 ndarray.__setitem__行为会调用__getitem__的 基本索引而不是先进的索引。对于这样的子类，最好 ndarray.__setitem__使用基类 ndarray 视图调用数据。如果子类不返回视图，则必须执行此操作__getitem__。
现场访问
也可以看看
数据类型对象（dtype），标量

如果 ndarray 对象是结构化数组，则可以通过使用字符串索引数组来访问数组的字段，类似于字典。

索引 x[‘field-name’]返回数组的新视图，该视图与 x 具有相同的形状（当字段是子数组时除外）但是数据类型 x.dtype[‘field-name’]并且仅包含指定字段中的部分数据。还 记录阵列标量可以被“索引”这种方式。

索引到结构化数组也可以使用字段名称列表来完成，例如 x[[‘field-name1′,’field-name2’]]。从 NumPy 1.16 开始，这将返回仅包含这些字段的视图。在旧版本的 numpy 中它返回了一个副本。有关多字段索引的详细信息，请参阅结构化阵列的用户指南部分。

如果访问的字段是子数组，则子数组的尺寸将附加到结果的形状。

例

>>>
>>> x = np.zeros((2,2), dtype=[('a', np.int32), ('b', np.float64, (3,3))])
>>> x['a'].shape
(2, 2)
>>> x['a'].dtype
dtype('int32')
>>> x['b'].shape
(2, 2, 3, 3)
>>> x['b'].dtype
dtype('float64')

Flat Iterator 索引

x.flat 返回一个迭代器，它将遍历整个数组（以 C -contiguous 样式，最后一个索引变化最快）。只要选择对象不是元组，也可以使用基本切片或高级索引对此迭代器对象建立索引。这应该从 x.flat 一维视图的事实中清楚。它可以用于具有 1 维 C 风格平面索引的整数索引。因此，任何返回数组的形状都是整数索引对象的形状。