Numpy第一次出现的值大于现有值

Question

我在numpy中有一个1D数组，我想找到索引的位置，其值超过numpy数组中的值。

E.g。

aa = range(-10,10)

在aa中查找位置，其中超出了值5。

Answer 1

这有点快（并且看起来更好）

np.argmax(aa>5)

由于argmax将停在第一个True（“如果多次出现最大值，则返回与第一次出现相对应的索引。”）并且不保存另一个列表

In [2]: N = 10000

In [3]: aa = np.arange(-N,N)

In [4]: timeit np.argmax(aa>N/2)
100000 loops, best of 3: 52.3 us per loop

In [5]: timeit np.where(aa>N/2)[0][0]
10000 loops, best of 3: 141 us per loop

In [6]: timeit np.nonzero(aa>N/2)[0][0]
10000 loops, best of 3: 142 us per loop

Answer 2

根据数组的排序内容，有一种更快的方法：searchsorted。

import time
N = 10000
aa = np.arange(-N,N)
%timeit np.searchsorted(aa, N/2)+1
%timeit np.argmax(aa>N/2)
%timeit np.where(aa>N/2)[0][0]
%timeit np.nonzero(aa>N/2)[0][0]

# Output
100000 loops, best of 3: 5.97 µs per loop
10000 loops, best of 3: 46.3 µs per loop
10000 loops, best of 3: 154 µs per loop
10000 loops, best of 3: 154 µs per loop

Answer 3

In [34]: a=np.arange(-10,10)

In [35]: a
Out[35]:
array([-10,  -9,  -8,  -7,  -6,  -5,  -4,  -3,  -2,  -1,   0,   1,   2,
         3,   4,   5,   6,   7,   8,   9])

In [36]: np.where(a>5)
Out[36]: (array([16, 17, 18, 19]),)

In [37]: np.where(a>5)[0][0]
Out[37]: 16

Answer 4

我也对此感兴趣，并且我已将所有建议的答案与perfplot进行了比较。 （免责声明：我是perfplot的作者。）

如果您知道您正在查看的数组已经排序，那么

numpy.searchsorted(a, alpha)

适合你。它是一个恒定时间操作，即，不的速度取决于阵列的大小。你不可能比这更快。

如果您对阵列一无所知，那么

numpy.argmax(a > alpha)

已经排序：

未排序：

重现情节的代码：

import numpy
import perfplot


alpha = 0.5

def argmax(data):
    return numpy.argmax(data > alpha)

def where(data):
    return numpy.where(data > alpha)[0][0]

def nonzero(data):
    return numpy.nonzero(data > alpha)[0][0]

def searchsorted(data):
    return numpy.searchsorted(data, alpha)

out = perfplot.show(
    # setup=numpy.random.rand,
    setup=lambda n: numpy.sort(numpy.random.rand(n)),
    kernels=[
        argmax, where,
        nonzero,
        searchsorted
        ],
    n_range=[2**k for k in range(2, 20)],
    logx=True,
    logy=True,
    xlabel='len(array)'
    )

Answer 5

在元素之间具有恒定步长的数组

如果是range或任何其他线性增加的数组，您可以简单地以编程方式计算索引，根本不需要实际迭代数组：

def first_index_calculate_range_like(val, arr):
    if len(arr) == 0:
        raise ValueError('no value greater than {}'.format(val))
    elif len(arr) == 1:
        if arr[0] > val:
            return 0
        else:
            raise ValueError('no value greater than {}'.format(val))

    first_value = arr[0]
    step = arr[1] - first_value
    # For linearly decreasing arrays or constant arrays we only need to check
    # the first element, because if that does not satisfy the condition
    # no other element will.
    if step <= 0:
        if first_value > val:
            return 0
        else:
            raise ValueError('no value greater than {}'.format(val))

    calculated_position = (val - first_value) / step

    if calculated_position < 0:
        return 0
    elif calculated_position > len(arr) - 1:
        raise ValueError('no value greater than {}'.format(val))

    return int(calculated_position) + 1

人们可能会改善这一点。我确保它对一些示例数组和值有效，但这并不意味着那里不会出现错误，特别是考虑到它使用浮点数...

>>> import numpy as np
>>> first_index_calculate_range_like(5, np.arange(-10, 10))
16
>>> np.arange(-10, 10)[16]  # double check
6

>>> first_index_calculate_range_like(4.8, np.arange(-10, 10))
15

鉴于它可以在没有任何迭代的情况下计算位置，它将是恒定时间（O(1)）并且可能超过所有其他提到的方法。但是它需要在数组中有一个恒定的步骤，否则会产生错误的结果。

使用numba的一般解决方案

更通用的方法是使用numba函数：

@nb.njit
def first_index_numba(val, arr):
    for idx in range(len(arr)):
        if arr[idx] > val:
            return idx
    return -1

这适用于任何数组，但它必须迭代数组，所以在一般情况下它将是O(n)：

>>> first_index_numba(4.8, np.arange(-10, 10))
15
>>> first_index_numba(5, np.arange(-10, 10))
16

基准

尽管NicoSchlömer已经提供了一些基准测试，但我认为包含我的新解决方案并测试不同的“价值”可能会有用。

测试设置：

import numpy as np
import math
import numba as nb

def first_index_using_argmax(val, arr):
    return np.argmax(arr > val)

def first_index_using_where(val, arr):
    return np.where(arr > val)[0][0]

def first_index_using_nonzero(val, arr):
    return np.nonzero(arr > val)[0][0]

def first_index_using_searchsorted(val, arr):
    return np.searchsorted(arr, val) + 1

def first_index_using_min(val, arr):
    return np.min(np.where(arr > val))

def first_index_calculate_range_like(val, arr):
    if len(arr) == 0:
        raise ValueError('empty array')
    elif len(arr) == 1:
        if arr[0] > val:
            return 0
        else:
            raise ValueError('no value greater than {}'.format(val))

    first_value = arr[0]
    step = arr[1] - first_value
    if step <= 0:
        if first_value > val:
            return 0
        else:
            raise ValueError('no value greater than {}'.format(val))

    calculated_position = (val - first_value) / step

    if calculated_position < 0:
        return 0
    elif calculated_position > len(arr) - 1:
        raise ValueError('no value greater than {}'.format(val))

    return int(calculated_position) + 1

@nb.njit
def first_index_numba(val, arr):
    for idx in range(len(arr)):
        if arr[idx] > val:
            return idx
    return -1

funcs = [
    first_index_using_argmax, 
    first_index_using_min, 
    first_index_using_nonzero,
    first_index_calculate_range_like, 
    first_index_numba, 
    first_index_using_searchsorted, 
    first_index_using_where
]

from simple_benchmark import benchmark, MultiArgument

并使用以下方式生成图：

%matplotlib notebook
b.plot()

项目位于开头

b = benchmark(
    funcs,
    {2**i: MultiArgument([0, np.arange(2**i)]) for i in range(2, 20)},
    argument_name="array size")

numba函数表现最佳，其次是calculate-function和searchsorted函数。其他解决方案的表现要差得多。

项目在最后

b = benchmark(
    funcs,
    {2**i: MultiArgument([2**i-2, np.arange(2**i)]) for i in range(2, 20)},
    argument_name="array size")

对于小型数组，numba函数执行速度惊人，但对于较大的数组，它的性能优于calculate-function和searchsorted函数。

项目位于sqrt（len）

b = benchmark(
    funcs,
    {2**i: MultiArgument([np.sqrt(2**i), np.arange(2**i)]) for i in range(2, 20)},
    argument_name="array size")

这更有趣。 numba和calculate函数再次表现很好，但这实际上触发了searchsorted的最坏情况，在这种情况下真的不能正常工作。

当没有值满足条件时的函数比较

另一个有趣的一点是，如果没有值应该返回索引，这些函数的行为如何：

arr = np.ones(100)
value = 2

for func in funcs:
    print(func.__name__)
    try:
        print('-->', func(value, arr))
    except Exception as e:
        print('-->', e)

结果如下：

first_index_using_argmax
--> 0
first_index_using_min
--> zero-size array to reduction operation minimum which has no identity
first_index_using_nonzero
--> index 0 is out of bounds for axis 0 with size 0
first_index_calculate_range_like
--> no value greater than 2
first_index_numba
--> -1
first_index_using_searchsorted
--> 101
first_index_using_where
--> index 0 is out of bounds for axis 0 with size 0

Searchsorted，argmax和numba只返回错误的值。但是searchsorted和numba返回的索引不是数组的有效索引。

函数where，min，nonzero和calculate会抛出异常。但是，只有calculate的例外实际上说了一些有用的内容。

这意味着实际上必须将这些调用包装在适当的包装函数中，该函数捕获异常或无效的返回值并进行适当的处​​理，至少如果您不确定该值是否可以在数组中。

注意：计算和searchsorted选项仅适用于特殊条件。 “calculate”函数需要一个常量步骤，searchsorted需要对数组进行排序。因此，这些在适当的情况下可能很有用，但对于此问题不是一般解决方案。如果您正在处理排序的 Python列表，您可能需要查看bisect模块而不是使用Numpys searchsorted。

Answer 6

我想提议

np.min(np.append(np.where(aa>5)[0],np.inf))

这将返回满足条件的最小索引，如果从未满足条件则返回无穷大（并且where返回一个空数组。）

Answer 7

我会选择

i = np.min(np.where(V >= x))

其中V是向量（1d数组），x是值，i是结果索引。