blocks|key|765773|text|据我所知，只有布尔数组上的np.any和np.all是短路的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|765774|在本例中，numpy必须遍历整个数组两次，一次是创建布尔条件，另一次是查找索引。|765775|在这种情况下，我的建议是使用cython。我认为在这种情况下调整示例应该很容易，特别是当您不需要为不同的数据类型和形状提供太多灵活性时。|765776|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As far as I know only np.any and np.all on boolean arrays are short-circuited.

In your case, numpy has to go through the entire array twice, once to create the boolean condition and a second time to find the indices.

My recommendation in this case would be to use cython. I think it should be easy to adjust an example for this case, especially if you don't need much flexibility for different dtypes and shapes.

blocks|key|549037|text|Numpy+2.0.0有一个预定的特性请求：https://github.com/numpy/numpy/issues/2269|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|549038|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/numpy/numpy/issues/2269^0|M|16|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There is a feature request for this scheduled for Numpy 2.0.0: <a href="https://github.com/numpy/numpy/issues/2269" rel="noreferrer">https://github.com/numpy/numpy/issues/2269</a>

blocks|key|765888|text|我的工作需要这个，所以我自学了Python和Numpy的C接口，并编写了自己的C接口。http://pastebin.com/GtcXuLyd它只适用于一维数组，但适用于大多数数据类型(整型、浮点型或字符串)，测试表明，它再次比纯Python-numpy中的预期方法快约20倍。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|765889|entityMap|0|LINK|mutability|MUTABLE|url|http://pastebin.com/GtcXuLyd^0|17|S|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I needed this for my job so I taught myself Python and Numpy's C interface and wrote my own. <a href="http://pastebin.com/GtcXuLyd" rel="nofollow">http://pastebin.com/GtcXuLyd</a> It's only for 1-D arrays, but works for most data types (int, float, or strings) and testing has shown it is again about 20 times faster than the expected approach in pure Python-numpy.

blocks|key|765949|text|您可以将数组转换为list并使用它的index()方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|765950|i+=+list(array).index(item)|code-block|syntax|javascript|765951|据我所知，这是一个C编译的方法。|765952|entityMap^0|9|4|I|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

You can covert your array into a <code>list</code> and use it's <code>index()</code> method:

<pre><code>i = list(array).index(item)
</code></pre>

As far as I'm aware, this is a C compiled method.

blocks|key|765995|text|您可以使用array.tostring()，然后使用find()方法将布尔数组转换为Python字符串：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|765996|(array==item).tostring().find('\x01')|code-block|syntax|javascript|765997|但是，这确实涉及到复制数据，因为Python字符串需要是不可变的。一个优点是，你还可以通过查找\x00\x01来搜索上升沿|765998|entityMap^0|5|G|0|0|1B|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

You can convert a boolean array to a Python string using <code>array.tostring()</code> and then using the find() method:

<pre><code>(array==item).tostring().find('\x01')
</code></pre>

This does involve copying the data, though, since Python strings need to be immutable. An advantage is that you can also search for e.g. a rising edge by finding <code>\x00\x01</code>

blocks|key|549288|text|在排序数组的情况下，np.searchsorted可以工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|549289|entityMap^0|A|F|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

In case of sorted arrays <code>np.searchsorted</code> works.

blocks|key|766077|text|只需注意，如果您正在执行一系列搜索，如果搜索维度不够大，那么执行一些巧妙的操作(如转换为字符串)可能会在外部循环中丢失性能增益。看看使用上面提出的字符串转换技巧的find1迭代的性能如何，以及沿着内轴使用argmax的find2的性能(加上确保不匹配的调整返回-1)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|766078|import+numpy,time
def+find1(arr,value):
++++return+(arr==value).tostring().find('\x01')

def+find2(arr,value):+#find+value+over+inner+most+axis,+and+return+array+of+indices+to+the+match
++++b+=+arr==value
++++return+b.argmax(axis=-1)+-+~(b.any())


for+size+in+[(1,100000000),(10000,10000),(1000000,100),(10000000,10)]:
++++print(size)
++++values+=+numpy.random.choice([0,0,0,0,0,0,0,1],size=size)
++++v+=+values>0

++++t=time.time()
++++numpy.apply_along_axis(find1,-1,v,1)
++++print('find1',time.time()-t)

++++t=time.time()
++++find2(v,1)
++++print('find2',time.time()-t)|code-block|syntax|javascript|766079|输出|766080|(1,+100000000)
('find1',+0.25300002098083496)
('find2',+0.2780001163482666)
(10000,+10000)
('find1',+0.46200013160705566)
('find2',+0.27300000190734863)
(1000000,+100)
('find1',+20.98099994659424)
('find2',+0.3040001392364502)
(10000000,+10)
('find1',+206.7590000629425)
('find2',+0.4830000400543213)|766081|也就是说，用C编写的find至少比这两种方法中的任何一种都要快一点|766082|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Just a note that if you are doing a sequence of searches, the performance gain from doing something clever like converting to string, might be lost in the outer loop if the search dimension isn't big enough. See how the performance of iterating find1 that uses the string conversion trick proposed above and find2 that uses argmax along the inner axis (plus an adjustment to ensure a non-match returns as -1)

<pre><code>import numpy,time
def find1(arr,value):
 return (arr==value).tostring().find('\x01')

def find2(arr,value): #find value over inner most axis, and return array of indices to the match
 b = arr==value
 return b.argmax(axis=-1) - ~(b.any())


for size in [(1,100000000),(10000,10000),(1000000,100),(10000000,10)]:
 print(size)
 values = numpy.random.choice([0,0,0,0,0,0,0,1],size=size)
 v = values&gt;0

 t=time.time()
 numpy.apply_along_axis(find1,-1,v,1)
 print('find1',time.time()-t)

 t=time.time()
 find2(v,1)
 print('find2',time.time()-t)
</code></pre>

outputs

<pre><code>(1, 100000000)
('find1', 0.25300002098083496)
('find2', 0.2780001163482666)
(10000, 10000)
('find1', 0.46200013160705566)
('find2', 0.27300000190734863)
(1000000, 100)
('find1', 20.98099994659424)
('find2', 0.3040001392364502)
(10000000, 10)
('find1', 206.7590000629425)
('find2', 0.4830000400543213)
</code></pre>

That said, a find written in C would be at least a little faster than either of these approaches

blocks|key|766131|text|虽然这对你来说太晚了，但是为了将来的参考:使用numba+(1)是最简单的方法，直到numpy实现它。如果你使用的是anaconda+python发行版，它应该已经安装了。代码将被编译，因此它将是快速的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|766132|@jit(nopython=True)
def+find_first(item,+vec):
++++"""return+the+index+of+the+first+occurence+of+item+in+vec"""
++++for+i+in+xrange(len(vec)):
++++++++if+item+==+vec[i]:
++++++++++++return+i
++++return+-1|code-block|syntax|javascript|766133|然后：|766134|>>>+a+=+array([1,7,8,32])
>>>+find_first(8,a)
2|766135|entityMap|0|LINK|mutability|MUTABLE|url|http://numba.pydata.org/^0|U|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Although it is way too late for you, but for future reference:
Using numba (<a href="http://numba.pydata.org/">1</a>) is the easiest way until numpy implements it. If you use anaconda python distribution it should already be installed.
The code will be compiled so it will be fast.

<pre><code>@jit(nopython=True)
def find_first(item, vec):
 """return the index of the first occurence of item in vec"""
 for i in xrange(len(vec)):
 if item == vec[i]:
 return i
 return -1
</code></pre>

and then:

<pre><code>&gt;&gt;&gt; a = array([1,7,8,32])
&gt;&gt;&gt; find_first(8,a)
2
</code></pre>

blocks|key|549417|text|这个怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|549418|import+numpy+as+np
np.amin(np.where(array==item))|code-block|syntax|javascript|549419|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

how about this 

<pre><code>import numpy as np
np.amin(np.where(array==item))
</code></pre>

blocks|key|766224|text|@tal已经提供了一个numba函数来查找第一个索引，但它只适用于一维数组。使用np.ndenumerate，您还可以找到任意维数组中的第一个索引：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|766225|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
++++return+None|code-block|syntax|javascript|766226|示例：|766227|>>>+arr+=+np.arange(9).reshape(3,3)
>>>+index(arr,+3)
(1,+0)|766228|计时显示，它在性能上与tals解决方案相似：|766229|arr+=+np.arange(100000)
%25timeit+index(arr,+5)+++++++++++#+1000000+loops,+best+of+3:+1.88+µs+per+loop
%25timeit+find_first(5,+arr)++++++#+1000000+loops,+best+of+3:+1.7+µs+per+loop

%25timeit+index(arr,+99999)+++++++#+10000+loops,+best+of+3:+118+µs+per+loop
%25timeit+find_first(99999,+arr)++#+10000+loops,+best+of+3:+96+µs+per+loop|766230|entityMap|0|LINK|mutability|MUTABLE|url|http://numba.pydata.org/numba-doc/dev/reference/numpysupported.html#other-functions|1|https://stackoverflow.com/a/29799815/5393381^0|B|5|14|E|14|E|0|0|0|0|0|B|4|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1B|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1D|8|@]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

@tal already presented a <code>numba</code> function to find the first index but that only works for 1D arrays. With <a href="http://numba.pydata.org/numba-doc/dev/reference/numpysupported.html#other-functions" rel="noreferrer"><code>np.ndenumerate</code></a> you can also find the first index in an arbitarly dimensional array:

<pre><code>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
 return None
</code></pre>

Sample case:

<pre><code>&gt;&gt;&gt; arr = np.arange(9).reshape(3,3)
&gt;&gt;&gt; index(arr, 3)
(1, 0)
</code></pre>

Timings show that it's similar in performance to <a href="https://stackoverflow.com/a/29799815/5393381">tals</a> solution:

<pre><code>arr = np.arange(100000)
%timeit index(arr, 5) # 1000000 loops, best of 3: 1.88 µs per loop
%timeit find_first(5, arr) # 1000000 loops, best of 3: 1.7 µs per loop

%timeit index(arr, 99999) # 10000 loops, best of 3: 118 µs per loop
%timeit find_first(99999, arr) # 10000 loops, best of 3: 96 µs per loop
</code></pre>

blocks|key|549580|text|作为一个长期使用matlab的人，我一直在寻找这个问题的有效解决方案。最后，受到讨论的启发，我试图提出一个解决方案，实现一个类似于建议的here的thread，目前仅支持一维阵列。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|549581|您可以像这样使用它|549582|import+numpy+as+np
import+utils_find_1st+as+utf1st
array+=+np.arange(100000)
item+=+1000
ind+=+utf1st.find_1st(array,+item,+utf1st.cmp_larger_eq)|code-block|syntax|javascript|549583|支持的条件运算符有:+cmp_equal、cmp_not_equal、cmp_larger、cmp_smaller、cmp_larger_eq、cmp_smaller_eq。为了提高效率，扩展是用c编写的。|549584|您可以在此处找到源代码、基准测试和其他详细信息：|549585|https://pypi.python.org/pypi?name=py_find_1st&:action=display|549586|为了在我们的团队中使用(+linux和macos上的anaconda+)，我做了一个anaconda安装程序，它简化了安装，您可以按照这里的描述使用它|549587|https://anaconda.org/roebel/py_find_1st|549588|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/numpy/numpy/issues/2269#issuecomment-9688943|1|https://github.com/numpy/numpy/issues/2269|2|3^0|1W|4|0|21|6|1|0|0|0|0|0|0|1P|2|0|0|0|13|3|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1E|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|U|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]|14|$5|X|Y|Z|C|$10|P]]|15|$5|X|Y|Z|C|$10|T]]]]

As a longtime matlab user I a have been searching for an efficient solution to this problem for quite a while. Finally, motivated by discussions a propositions in this <a href="https://github.com/numpy/numpy/issues/2269" rel="nofollow noreferrer">thread</a> I have tried to come up with a solution that is implementing an API similar to what was suggested <a href="https://github.com/numpy/numpy/issues/2269#issuecomment-9688943" rel="nofollow noreferrer">here</a>, supporting for the moment only 1D arrays. 

You would use it like this

<pre><code>import numpy as np
import utils_find_1st as utf1st
array = np.arange(100000)
item = 1000
ind = utf1st.find_1st(array, item, utf1st.cmp_larger_eq)
</code></pre>

The condition operators supported are: cmp_equal, cmp_not_equal, cmp_larger, cmp_smaller, cmp_larger_eq, cmp_smaller_eq. For efficiency the extension is written in c.

You find the source, benchmarks and other details here:

<a href="https://pypi.python.org/pypi?name=py_find_1st&amp;:action=display" rel="nofollow noreferrer">https://pypi.python.org/pypi?name=py_find_1st&amp;:action=display</a>

for the use in our team (anaconda on linux and macos) I have made an anaconda installer that simplifies installation, you may use it as described here

<a href="https://anaconda.org/roebel/py_find_1st" rel="nofollow noreferrer">https://anaconda.org/roebel/py_find_1st</a>

blocks|key|549674|text|这个问题可以通过分块处理数组在纯numpy中有效地解决：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|549675|def+find_first(x):
++++idx,+step+=+0,+32
++++while+idx+<+x.size:
++++++++nz,+=+x[idx:+idx+%2B+step].nonzero()
++++++++if+len(nz):+#+found+non-zero,+return+it
++++++++++++return+nz[0]+%2B+idx
++++++++#+move+to+the+next+chunk,+increase+step
++++++++idx+%2B=+step
++++++++step+=+min(9600,+step+%2B+step+//+2)
++++return+-1|code-block|syntax|javascript|549676|该数组是以step大小的块进行处理的。step的步长越长，置零数组的处理速度就越快(最坏的情况)。它越小，开始时处理非零数组的速度就越快。诀窍是从一个小的step开始，然后指数级地增加它。此外，由于收益有限，没有必要将其增加到某个阈值以上。|offset|length|style|CODE|549677|我已经将该解决方案与纯ndarary.nonzero和numba解决方案与1000万个浮点数组进行了比较。|549678|import+numpy+as+np
from+numba+import+jit
from+timeit+import+timeit

def+find_first(x):
++++idx,+step+=+0,+32
++++while+idx+<+x.size:
++++++++nz,+=+x[idx:+idx+%2B+step].nonzero()
++++++++if+len(nz):
++++++++++++return+nz[0]+%2B+idx
++++++++idx+%2B=+step
++++++++step+=+min(9600,+step+%2B+step+//+2)
++++return+-1

@jit(nopython=True)
def+find_first_numba(vec):
++++"""return+the+index+of+the+first+occurence+of+item+in+vec"""
++++for+i+in+range(len(vec)):
++++++++if+vec[i]:
++++++++++++return+i
++++return+-1


SIZE+=+10_000_000
#+First+only
x+=+np.empty(SIZE)

find_first_numba(x[:10])

print('----+FIRST+----')
x[:]+=+0
x[0]+=+1
print('ndarray.nonzero',+timeit(lambda:+x.nonzero()[0][0],+number=100)*10,+'ms')
print('find_first',+timeit(lambda:+find_first(x),+number=1000),+'ms')
print('find_first_numba',+timeit(lambda:+find_first_numba(x),+number=1000),+'ms')

print('----+LAST+----')
x[:]+=+0
x[-1]+=+1
print('ndarray.nonzero',+timeit(lambda:+x.nonzero()[0][0],+number=100)*10,+'ms')
print('find_first',+timeit(lambda:+find_first(x),+number=100)*10,+'ms')
print('find_first_numba',+timeit(lambda:+find_first_numba(x),+number=100)*10,+'ms')

print('----+NONE+----')
x[:]+=+0
print('ndarray.nonzero',+timeit(lambda:+x.nonzero()[0],+number=100)*10,+'ms')
print('find_first',+timeit(lambda:+find_first(x),+number=100)*10,+'ms')
print('find_first_numba',+timeit(lambda:+find_first_numba(x),+number=100)*10,+'ms')

print('----+ALL+----')
x[:]+=+1
print('ndarray.nonzero',+timeit(lambda:+x.nonzero()[0][0],+number=100)*10,+'ms')
print('find_first',+timeit(lambda:+find_first(x),+number=100)*10,+'ms')
print('find_first_numba',+timeit(lambda:+find_first_numba(x),+number=100)*10,+'ms')|549679|以及我的机器上的结果：|549680|----+FIRST+----
ndarray.nonzero+54.733994480002366+ms
find_first+0.0013148509997336078+ms
find_first_numba+0.0002839310000126716+ms
----+LAST+----
ndarray.nonzero+54.56336712999928+ms
find_first+25.38929685000312+ms
find_first_numba+8.022820680002951+ms
----+NONE+----
ndarray.nonzero+24.13432420999925+ms
find_first+25.345200140000088+ms
find_first_numba+8.154927100003988+ms
----+ALL+----
ndarray.nonzero+55.753537260002304+ms
find_first+0.0014760300018679118+ms
find_first_numba+0.0004358099977253005+ms|549681|纯ndarray.nonzero绝对更松散。在最好的情况下，numba解决方案大约快5倍。在最坏的情况下，它大约快3倍。|549682|entityMap^0|0|0|5|4|J|4|25|4|0|0|0|0|0|1|F|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@$I|1C|J|1D|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

This problem can be effectively solved in pure numpy by processing the array in chunks:

<pre><code>def find_first(x):
 idx, step = 0, 32
 while idx &lt; x.size:
 nz, = x[idx: idx + step].nonzero()
 if len(nz): # found non-zero, return it
 return nz[0] + idx
 # move to the next chunk, increase step
 idx += step
 step = min(9600, step + step // 2)
 return -1
</code></pre>

The array is processed in chunk of size <code>step</code>. The <code>step</code> longer the step is, the faster is processing of zeroed-array (worst case). The smaller it is, the faster processing of array with non-zero at the start. The trick is to start with a small <code>step</code> and increase it exponentially. Moreover, there is no need to increment it above some threshold due to limited benefits.

I've compared the solution with pure ndarary.nonzero and numba solution against 10 million array of floats.

<pre><code>import numpy as np
from numba import jit
from timeit import timeit

def find_first(x):
 idx, step = 0, 32
 while idx &lt; x.size:
 nz, = x[idx: idx + step].nonzero()
 if len(nz):
 return nz[0] + idx
 idx += step
 step = min(9600, step + step // 2)
 return -1

@jit(nopython=True)
def find_first_numba(vec):
 """return the index of the first occurence of item in vec"""
 for i in range(len(vec)):
 if vec[i]:
 return i
 return -1


SIZE = 10_000_000
# First only
x = np.empty(SIZE)

find_first_numba(x[:10])

print('---- FIRST ----')
x[:] = 0
x[0] = 1
print('ndarray.nonzero', timeit(lambda: x.nonzero()[0][0], number=100)*10, 'ms')
print('find_first', timeit(lambda: find_first(x), number=1000), 'ms')
print('find_first_numba', timeit(lambda: find_first_numba(x), number=1000), 'ms')

print('---- LAST ----')
x[:] = 0
x[-1] = 1
print('ndarray.nonzero', timeit(lambda: x.nonzero()[0][0], number=100)*10, 'ms')
print('find_first', timeit(lambda: find_first(x), number=100)*10, 'ms')
print('find_first_numba', timeit(lambda: find_first_numba(x), number=100)*10, 'ms')

print('---- NONE ----')
x[:] = 0
print('ndarray.nonzero', timeit(lambda: x.nonzero()[0], number=100)*10, 'ms')
print('find_first', timeit(lambda: find_first(x), number=100)*10, 'ms')
print('find_first_numba', timeit(lambda: find_first_numba(x), number=100)*10, 'ms')

print('---- ALL ----')
x[:] = 1
print('ndarray.nonzero', timeit(lambda: x.nonzero()[0][0], number=100)*10, 'ms')
print('find_first', timeit(lambda: find_first(x), number=100)*10, 'ms')
print('find_first_numba', timeit(lambda: find_first_numba(x), number=100)*10, 'ms')

</code></pre>

And results on my machine:

<pre><code>---- FIRST ----
ndarray.nonzero 54.733994480002366 ms
find_first 0.0013148509997336078 ms
find_first_numba 0.0002839310000126716 ms
---- LAST ----
ndarray.nonzero 54.56336712999928 ms
find_first 25.38929685000312 ms
find_first_numba 8.022820680002951 ms
---- NONE ----
ndarray.nonzero 24.13432420999925 ms
find_first 25.345200140000088 ms
find_first_numba 8.154927100003988 ms
---- ALL ----
ndarray.nonzero 55.753537260002304 ms
find_first 0.0014760300018679118 ms
find_first_numba 0.0004358099977253005 ms
</code></pre>

Pure <code>ndarray.nonzero</code> is definite looser. The numba solution is circa 5 times faster for the best case. It is circa 3 times faster in the worst case.

How can I find the index of the first occurrence of a number in a Numpy array?
Speed is important to me. I am not interested in the following answers because they scan the whole array and don't stop when they find the first occurrence:

<pre><code>itemindex = numpy.where(array==item)[0][0]
nonzero(array == item)[0][0]
</code></pre>

Note 1: none of the answers from that question seem relevant <a href="https://stackoverflow.com/questions/432112/python-numpy-array-help-is-there-a-function-to-return-the-index-of-something-in">Is there a Numpy function to return the first index of something in an array?</a>

Note 2: using a C-compiled method is preferred to a Python loop.

Numpy: find first index of value fast

Python

如何在Numpy数组中找到数字第一次出现的索引？速度对我来说很重要。我对以下答案不感兴趣，因为它们扫描整个数组，并且在找到第一个匹配项时不会停止：itemindex = numpy.where(array==item)[0][0]nonzero(array == item)[0][0]注1:这个问题的答案似乎都不相关注...

问Numpy:快速找到第一个值索引
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Numpy:快速找到第一个值索引EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Numpy:快速找到第一个值索引
EN