我知道Python列表有一种方法可以返回第一个索引：
>>> l = [1, 2, 3]
>>> l.index(2)
1
NumPy数组有类似内容吗？
答案 0 :(得分：460)
是的，这是给出NumPy数组array和值item的答案，以便搜索：
itemindex = numpy.where(array==item)
结果是一个元组，首先是所有行索引，然后是所有列索引。
例如，如果一个数组是两个维度，并且它在两个位置包含您的项目，那么
array[itemindex[0][0]][itemindex[1][0]]
将等于您的项目，因此
array[itemindex[0][1]][itemindex[1][1]]
答案 1 :(得分：62)
如果您需要第一次出现的只有一个值的索引，您可以使用nonzero（或where，在这种情况下相同的事情相同） ：
>>> t = array([1, 1, 1, 2, 2, 3, 8, 3, 8, 8])
>>> nonzero(t == 8)
(array([6, 8, 9]),)
>>> nonzero(t == 8)[0][0]
6
如果您需要每个多个值的第一个索引，您显然可以反复执行上述操作，但有一个技巧可能更快。以下内容查找每个子序列的第一个元素的索引：
>>> nonzero(r_[1, diff(t)[:-1]])
(array([0, 3, 5, 6, 7, 8]),)
请注意，它找到了3的子序列的开头和8s的两个子序列：
[ 1 ，1,1， 2 ，2， 3 ， 8 ， 3 ， 8 ，8]
所以它与找到每个值的第一个出现略有不同。在您的计划中，您可以使用排序版本的t来获得您想要的内容：
>>> st = sorted(t)
>>> nonzero(r_[1, diff(st)[:-1]])
(array([0, 3, 5, 7]),)
答案 2 :(得分：40)
您还可以将NumPy数组转换为空中列表并获取其索引。例如，
l = [1,2,3,4,5] # Python list
a = numpy.array(l) # NumPy array
i = a.tolist().index(2) # i will return index of 2
print i
它会打印1。
答案 3 :(得分：14)
如果您要将其用作其他内容的索引，则可以使用布尔索引（如果数组是可广播的）;你不需要明确的指数。绝对最简单的方法是简单地根据真值进行索引。
other_array[first_array == item]
任何布尔操作都有效：
a = numpy.arange(100)
other_array[first_array > 50]
非零方法也需要布尔值：
index = numpy.nonzero(first_array == item)[0][0]
两个零用于索引的元组（假设first_array是1D），然后是索引数组中的第一个项。
答案 4 :(得分：13)
只需添加一个基于numba的高性能且方便的np.ndenumerate替代方案来查找第一个索引：
from numba import njit
import numpy as np
@njit
def index(array, item):
for idx, val in np.ndenumerate(array):
if val == item:
return idx
# If no item was found return None, other return types might be a problem due to
# numbas type inference.
这非常快，自然地处理多维数组：
>>> arr1 = np.ones((100, 100, 100))
>>> arr1[2, 2, 2] = 2
>>> index(arr1, 2)
(2, 2, 2)
>>> arr2 = np.ones(20)
>>> arr2[5] = 2
>>> index(arr2, 2)
(5,)
与使用np.where或np.nonzero的任何方法相比，快得多（因为它会使操作短路）。
然而np.argwhere也可以使用多维数组优雅地处理 （您需要手动将其转换为元组和它不会短路）但它如果找不到匹配则会失败：
>>> tuple(np.argwhere(arr1 == 2)[0])
(2, 2, 2)
>>> tuple(np.argwhere(arr2 == 2)[0])
(5,)
答案 5 :(得分：8)
l.index(x)返回最小的 i ，以便 i 是列表中第一次出现x的索引。
可以放心地假设Python中的index()函数已经实现，以便在找到第一个匹配项后停止，这样可以获得最佳的平均性能。
要查找在NumPy数组中第一次匹配后停止的元素，请使用迭代器（ndenumerate）。
In [67]: l=range(100)
In [68]: l.index(2)
Out[68]: 2
NumPy数组：
In [69]: a = np.arange(100)
In [70]: next((idx for idx, val in np.ndenumerate(a) if val==2))
Out[70]: (2L,)
请注意，如果找不到元素，则index()和next两种方法都会返回错误。使用next，可以使用第二个参数在未找到元素的情况下返回特殊值，例如。
In [77]: next((idx for idx, val in np.ndenumerate(a) if val==400),None)
NumPy中有其他函数（argmax，where和nonzero）可用于查找数组中的元素，但它们都有缺点整个数组寻找所有次出现，因此没有针对查找第一个元素进行优化。另请注意where和nonzero返回数组，因此您需要选择第一个元素来获取索引。
In [71]: np.argmax(a==2)
Out[71]: 2
In [72]: np.where(a==2)
Out[72]: (array([2], dtype=int64),)
In [73]: np.nonzero(a==2)
Out[73]: (array([2], dtype=int64),)
只检查大型数组，当搜索项位于数组的开头时，使用迭代器的解决方案更快（在IPython shell中使用%timeit）：
In [285]: a = np.arange(100000)
In [286]: %timeit next((idx for idx, val in np.ndenumerate(a) if val==0))
100000 loops, best of 3: 17.6 µs per loop
In [287]: %timeit np.argmax(a==0)
1000 loops, best of 3: 254 µs per loop
In [288]: %timeit np.where(a==0)[0][0]
1000 loops, best of 3: 314 µs per loop
这是一个开放的NumPy GitHub issue。
答案 6 :(得分：6)
要对任何条件进行索引，您可以执行以下操作：
In [1]: from numpy import *
In [2]: x = arange(125).reshape((5,5,5))
In [3]: y = indices(x.shape)
In [4]: locs = y[:,x >= 120] # put whatever you want in place of x >= 120
In [5]: pts = hsplit(locs, len(locs[0]))
In [6]: for pt in pts:
.....: print(', '.join(str(p[0]) for p in pt))
4, 4, 0
4, 4, 1
4, 4, 2
4, 4, 3
4, 4, 4
这里有一个快速的函数来执行list.index（）所做的事情，除非没有找到它引发异常。注意 - 这在大型阵列上可能非常慢。如果你更愿意将它作为一种方法使用，你可以将它修补到数组上。
def ndindex(ndarray, item):
if len(ndarray.shape) == 1:
try:
return [ndarray.tolist().index(item)]
except:
pass
else:
for i, subarray in enumerate(ndarray):
try:
return [i] + ndindex(subarray, item)
except:
pass
In [1]: ndindex(x, 103)
Out[1]: [4, 0, 3]
答案 7 :(得分：5)
对于1D阵列，我建议使用np.flatnonzero(array == value)[0]，这相当于np.nonzero(array == value)[0][0]和np.where(array == value)[0][0]，但避免了取消装箱1元素元组的丑陋。
答案 8 :(得分：4)
NumPy中有很多操作可能可以放在一起来完成这个任务。这将返回元素的索引等于item：
numpy.nonzero(array - item)
然后，您可以获取列表的第一个元素以获得单个元素。
答案 9 :(得分：4)
对于一维排序数组，使用numpy.searchsorted返回NumPy整数（位置）会更简单有效O（log（n））。例如，
arr = np.array([1, 1, 1, 2, 3, 3, 4])
i = np.searchsorted(arr, 3)
确保数组已经排序
同时检查返回的索引i是否实际包含搜索的元素，因为searchsorted的主要目标是找到应插入元素以保持顺序的索引。
if arr[i] == 3:
print("present")
else:
print("not present")
答案 10 :(得分：2)
从np.where（）中选择第一个元素的另一种方法是使用生成器表达式和枚举，例如：
>>> import numpy as np
>>> x = np.arange(100) # x = array([0, 1, 2, 3, ... 99])
>>> next(i for i, x_i in enumerate(x) if x_i == 2)
2
对于二维数组，可以这样做：
>>> x = np.arange(100).reshape(10,10) # x = array([[0, 1, 2,... 9], [10,..19],])
>>> next((i,j) for i, x_i in enumerate(x)
... for j, x_ij in enumerate(x_i) if x_ij == 2)
(0, 2)
这种方法的优点是它在找到第一个匹配后停止检查数组的元素，而np.where检查所有元素是否匹配。如果在数组的早期匹配，则生成器表达式会更快。
答案 11 :(得分：1)
numpy_indexed包（免责声明，我是它的作者）包含numpy.ndarray的矢量化等效list.index;那就是：
sequence_of_arrays = [[0, 1], [1, 2], [-5, 0]]
arrays_to_query = [[-5, 0], [1, 0]]
import numpy_indexed as npi
idx = npi.indices(sequence_of_arrays, arrays_to_query, missing=-1)
print(idx) # [2, -1]
这个解决方案具有矢量化性能，可以推广到ndarrays，并且有各种处理缺失值的方法。
答案 12 :(得分：0)
使用 ndindex
样本数组
arr = np.array([[1,4],
[2,3]])
print(arr)
...[[1,4],
[2,3]]
创建一个空列表来存储索引和元素元组
index_elements = []
for i in np.ndindex(arr.shape):
index_elements.append((arr[i],i))
将元组列表转换为字典
index_elements = dict(index_elements)
键是元素，值是它们的 索引 - 使用键访问索引
index_elements[4]
... (0,1)
答案 13 :(得分：0)
找到另一个带有循环的解决方案：
new_array_of_indicies = []
for i in range(len(some_array)):
if some_array[i] == some_value:
new_array_of_indicies.append(i)
答案 14 :(得分：0)
numpy 中内置了一种相当惯用且矢量化的方法来执行此操作。它使用 np.argmax() 函数的一个怪癖来实现这一点——如果许多值匹配，它返回第一个匹配项的索引。诀窍是对于布尔值，永远只有两个值：True (1) 和 False (0)。因此，返回的索引将是第一个 True 的索引。
对于提供的简单示例，您可以看到它与以下内容一起使用
>>> np.argmax(np.array([1,2,3]) == 2)
1
一个很好的例子是计算桶，例如用于分类。假设您有一个切割点数组，并且您想要与数组中的每个元素对应的“桶”。该算法是计算 cuts 的第一个索引，其中 x < cuts（在用 cuts 填充 np.Infitnity 之后）。我可以使用广播来广播比较，然后沿 cuts 广播轴应用 argmax。
>>> cuts = np.array([10, 50, 100])
>>> cuts_pad = np.array([*cuts, np.Infinity])
>>> x = np.array([7, 11, 80, 443])
>>> bins = np.argmax( x[:, np.newaxis] < cuts_pad[np.newaxis, :], axis = 1)
>>> print(bins)
[0, 1, 2, 3]
正如预期的那样，来自 x 的每个值都落入一个连续的 bin 中，具有明确定义且易于指定的边缘情况行为。
答案 15 :(得分：0)
之前没有提到的另一个选项是 bisect 模块，它也适用于列表，但需要预先排序的列表/数组：
import bisect
import numpy as np
z = np.array([104,113,120,122,126,138])
bisect.bisect_left(z, 122)
收益
3
bisect 也会在数组中不存在您要查找的数字时返回结果，以便将数字插入正确的位置。
答案 16 :(得分：-1)
注意：这适用于python 2.7版本
您可以使用lambda函数来处理问题，它可以在NumPy数组和列表上运行。
your_list = [11, 22, 23, 44, 55]
result = filter(lambda x:your_list[x]>30, range(len(your_list)))
#result: [3, 4]
import numpy as np
your_numpy_array = np.array([11, 22, 23, 44, 55])
result = filter(lambda x:your_numpy_array [x]>30, range(len(your_list)))
#result: [3, 4]
你可以使用
result[0]
获取已过滤元素的第一个索引。
对于python 3.6，请使用
list(result)
而不是
result