blocks|key|271094|text|这是一个老帖子，但不管怎样，如果有人再看这个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|271095|当同时寻找最小和最大值时，可以减少比较次数。如果你比较的是浮点数(我猜是这样)，这可能会节省你的时间，尽管不会带来计算复杂性。|271096|代替(Python代码)：|271097|_max+=+ar[0]
_min=++ar[0]
for+ii+in+xrange(len(ar)):
++++if+_max+>+ar[ii]:+_max+=+ar[ii]
++++if+_min+<+ar[ii]:+_min+=+ar[ii]|code-block|syntax|javascript|271098|您可以首先比较数组中的两个相邻的值，然后仅将较小的值与当前的最小值进行比较，将较大的值与当前的最大值进行比较：|271099|##+for+an+even-sized+array
_max+=+ar[0]
_min+=+ar[0]
for+ii+in+xrange(0,+len(ar),+2)):++##+iterate+over+every+other+value+in+the+array
++++f1+=+ar[ii]
++++f2+=+ar[ii%2B1]
++++if+(f1+<+f2):
++++++++if+f1+<+_min:+_min+=+f1
++++++++if+f2+>+_max:+_max+=+f2
++++else:
++++++++if+f2+<+_min:+_min+=+f2
++++++++if+f1+>+_max:+_max+=+f1|271100|这里的代码是用Python语言编写的，显然为了提高速度，你可以使用C、Fortran或Cython语言，但这样你就可以在每次迭代中进行3次比较，使用len(ar)/2迭代，给出3/2+*+len(ar)比较。与之相反，以“显而易见的方式”进行比较，您在每次迭代中进行两次比较，从而导致2*len(ar)比较。为您节省25%25的比较时间。|271101|也许有一天有人会发现这很有用。|271102|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

This is an old thread, but anyway, if anyone ever looks at this again...

When looking for the min and max simultaneously, it is possible to reduce the number of comparisons. If it is floats you are comparing (which I guess it is) this might save you some time, although not computational complexity. 

Instead of (Python code):

<pre><code>_max = ar[0]
_min= ar[0]
for ii in xrange(len(ar)):
 if _max &gt; ar[ii]: _max = ar[ii]
 if _min &lt; ar[ii]: _min = ar[ii]
</code></pre>

you can first compare two adjacent values in the array, and then only compare the smaller one against current minimum, and the larger one against current maximum:

<pre><code>## for an even-sized array
_max = ar[0]
_min = ar[0]
for ii in xrange(0, len(ar), 2)): ## iterate over every other value in the array
 f1 = ar[ii]
 f2 = ar[ii+1]
 if (f1 &lt; f2):
 if f1 &lt; _min: _min = f1
 if f2 &gt; _max: _max = f2
 else:
 if f2 &lt; _min: _min = f2
 if f1 &gt; _max: _max = f1
</code></pre>

The code here is written in Python, clearly for speed you would use C or Fortran or Cython, but this way you do 3 comparisons per iteration, with len(ar)/2 iterations, giving 3/2 * len(ar) comparisons. As opposed to that, doing the comparison "the obvious way" you do two comparisons per iteration, leading to 2*len(ar) comparisons. Saves you 25% of comparison time. 

Maybe someone one day will find this useful.

blocks|key|271162|text|您可以使用Numba，它是一个使用LLVM的支持NumPy的动态Python编译器。由此产生的实现非常简单和清晰：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|271163|import+numpy
import+numba


@numba.jit
def+minmax(x):
++++maximum+=+x[0]
++++minimum+=+x[0]
++++for+i+in+x[1:]:
++++++++if+i+>+maximum:
++++++++++++maximum+=+i
++++++++elif+i+<+minimum:
++++++++++++minimum+=+i
++++return+(minimum,+maximum)


numpy.random.seed(1)
x+=+numpy.random.rand(1000000)
print(minmax(x)+==+(x.min(),+x.max()))|code-block|syntax|javascript|271164|它也应该比Numpy的min()+&+max()实现更快。这一切都不需要编写任何C/Fortran代码。|style|CODE|271165|做你自己的性能测试，因为它总是依赖于你的架构，你的数据，你的包版本……|271166|entityMap|0|LINK|mutability|MUTABLE|url|http://numba.pydata.org/^0|5|5|0|0|0|B|D|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

You could use <a href="http://numba.pydata.org/" rel="noreferrer">Numba</a>, which is a NumPy-aware dynamic Python compiler using LLVM. The resulting implementation is pretty simple and clear:

<pre><code>import numpy
import numba


@numba.jit
def minmax(x):
 maximum = x[0]
 minimum = x[0]
 for i in x[1:]:
 if i &gt; maximum:
 maximum = i
 elif i &lt; minimum:
 minimum = i
 return (minimum, maximum)


numpy.random.seed(1)
x = numpy.random.rand(1000000)
print(minmax(x) == (x.min(), x.max()))
</code></pre>

It should also be faster than a Numpy's <code>min() &amp; max()</code> implementation. And all without having to write a single C/Fortran line of code.

Do your own performance tests, as it is always dependent on your architecture, your data, your package versions...

blocks|key|488333|text|通常，您可以通过一次处理两个元素并仅将较小的元素与临时最小值进行比较，将较大的元素与临时最大值进行比较，来减少minmax算法的比较次数。平均来说，一个人只需要3/4的比较，而不是天真的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488334|这可以用c或fortran+(或任何其他低级语言)实现，并且在性能方面应该几乎是无与伦比的。我使用numba来说明这个原理，并得到一个非常快速的、独立于dtype的实现：|offset|length|488335|import+numba+as+nb
import+numpy+as+np

@nb.njit
def+minmax(array):
++++#+Ravel+the+array+and+return+early+if+it's+empty
++++array+=+array.ravel()
++++length+=+array.size
++++if+not+length:
++++++++return

++++#+We+want+to+process+two+elements+at+once+so+we+need
++++#+an+even+sized+array,+but+we+preprocess+the+first+and
++++#+start+with+the+second+element,+so+we+want+it+"odd"
++++odd+=+length+%25+2
++++if+not+odd:
++++++++length+-=+1

++++#+Initialize+min+and+max+with+the+first+item
++++minimum+=+maximum+=+array[0]

++++i+=+1
++++while+i+<+length:
++++++++#+Get+the+next+two+items+and+swap+them+if+necessary
++++++++x+=+array[i]
++++++++y+=+array[i%2B1]
++++++++if+x+>+y:
++++++++++++x,+y+=+y,+x
++++++++#+Compare+the+min+with+the+smaller+one+and+the+max
++++++++#+with+the+bigger+one
++++++++minimum+=+min(x,+minimum)
++++++++maximum+=+max(y,+maximum)
++++++++i+%2B=+2

++++#+If+we+had+an+even+sized+array+we+need+to+compare+the
++++#+one+remaining+item+too.
++++if+not+odd:
++++++++x+=+array[length]
++++++++minimum+=+min(x,+minimum)
++++++++maximum+=+max(x,+maximum)

++++return+minimum,+maximum|code-block|syntax|javascript|488336|这绝对比Peque提出的幼稚方法要快得多：|488337|arr+=+np.random.random(3000000)
assert+minmax(arr)+==+minmax_peque(arr)++#+warmup+and+making+sure+they+are+identical+
%25timeit+minmax(arr)++++++++++++#+100+loops,+best+of+3:+2.1+ms+per+loop
%25timeit+minmax_peque(arr)++++++#+100+loops,+best+of+3:+2.75+ms+per+loop|488338|正如预期的那样，新的最小最大实现只需要原始实现所需时间的大约3/4+(2.1+/+2.75+=+0.7636363636363637)|style|CODE|488339|entityMap|0|LINK|mutability|MUTABLE|url|/questions/tagged/numba|1|https://stackoverflow.com/a/33919126/5393381^0|0|1D|5|0|0|0|4|5|1|0|0|Z|V|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|M|3|N|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1D|8|@$D|1E|E|1F|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

In general you can reduce the amount of comparisons for a minmax algorithm by processing two elements at a time and only comparing the smaller to the temporary minimum and the bigger one to the temporary maximum. On average one needs only 3/4 of the comparisons than a naive approach.

This could be implemented in c or fortran (or any other low-level language) and should be almost unbeatable in terms of performance. I'm using <a href="/questions/tagged/numba" class="post-tag" title="show questions tagged &#39;numba&#39;" rel="tag">numba</a> to illustrate the principle and get a very fast, dtype-independant implementation:

<pre><code>import numba as nb
import numpy as np

@nb.njit
def minmax(array):
 # Ravel the array and return early if it's empty
 array = array.ravel()
 length = array.size
 if not length:
 return

 # We want to process two elements at once so we need
 # an even sized array, but we preprocess the first and
 # start with the second element, so we want it "odd"
 odd = length % 2
 if not odd:
 length -= 1

 # Initialize min and max with the first item
 minimum = maximum = array[0]

 i = 1
 while i &lt; length:
 # Get the next two items and swap them if necessary
 x = array[i]
 y = array[i+1]
 if x &gt; y:
 x, y = y, x
 # Compare the min with the smaller one and the max
 # with the bigger one
 minimum = min(x, minimum)
 maximum = max(y, maximum)
 i += 2

 # If we had an even sized array we need to compare the
 # one remaining item too.
 if not odd:
 x = array[length]
 minimum = min(x, minimum)
 maximum = max(x, maximum)

 return minimum, maximum
</code></pre>

It's definetly faster than the naive approach that <a href="https://stackoverflow.com/a/33919126/5393381">Peque</a> presented:

<pre><code>arr = np.random.random(3000000)
assert minmax(arr) == minmax_peque(arr) # warmup and making sure they are identical 
%timeit minmax(arr) # 100 loops, best of 3: 2.1 ms per loop
%timeit minmax_peque(arr) # 100 loops, best of 3: 2.75 ms per loop
</code></pre>

As expected the new minmax implementation only takes roughly 3/4 of the time the naive implementation took (<code>2.1 / 2.75 = 0.7636363636363637</code>)

blocks|key|488416|text|我想出的最短的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488417|mn,+mx+=+np.sort(ar)[[0,+-1]]|code-block|syntax|javascript|488418|但由于它对数组进行排序，所以效率不是最高的。|488419|另一种简单的方法是：|488420|mn,+mx+=+np.percentile(ar,+[0,+100])|488421|这应该更有效，但结果是计算出来的，并返回一个浮点数。|488422|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The shortest way I've come up with is this:

<pre><code>mn, mx = np.sort(ar)[[0, -1]]
</code></pre>

But since it sorts the array, it's not the most efficient.

Another short way would be:

<pre><code>mn, mx = np.percentile(ar, [0, 100])
</code></pre>

This should be more efficient, but the result is calculated, and a float is returned.

blocks|key|271409|text|给出以下方法，只是为了了解一些人们可以预期的数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|271410|import+numpy+as+np


def+extrema_np(arr):
++++return+np.max(arr),+np.min(arr)|code-block|syntax|javascript|271411|import+numba+as+nb


@nb.jit(nopython=True)
def+extrema_loop_nb(arr):
++++n+=+arr.size
++++max_val+=+min_val+=+arr[0]
++++for+i+in+range(1,+n):
++++++++item+=+arr[i]
++++++++if+item+>+max_val:
++++++++++++max_val+=+item
++++++++elif+item+<+min_val:
++++++++++++min_val+=+item
++++return+max_val,+min_val|271412|import+numba+as+nb


@nb.jit(nopython=True)
def+extrema_while_nb(arr):
++++n+=+arr.size
++++odd+=+n+%25+2
++++if+not+odd:
++++++++n+-=+1
++++max_val+=+min_val+=+arr[0]
++++i+=+1
++++while+i+<+n:
++++++++x+=+arr[i]
++++++++y+=+arr[i+%2B+1]
++++++++if+x+>+y:
++++++++++++x,+y+=+y,+x
++++++++min_val+=+min(x,+min_val)
++++++++max_val+=+max(y,+max_val)
++++++++i+%2B=+2
++++if+not+odd:
++++++++x+=+arr[n]
++++++++min_val+=+min(x,+min_val)
++++++++max_val+=+max(x,+max_val)
++++return+max_val,+min_val|271413|%25%25cython+-c-O3+-c-march=native+-a
#cython:+language_level=3,+boundscheck=False,+wraparound=False,+initializedcheck=False,+cdivision=True,+infer_types=True


import+numpy+as+np


cdef+void+_extrema_loop_cy(
++++++++long[:]+arr,
++++++++size_t+n,
++++++++long[:]+result):
++++cdef+size_t+i
++++cdef+long+item,+max_val,+min_val
++++max_val+=+arr[0]
++++min_val+=+arr[0]
++++for+i+in+range(1,+n):
++++++++item+=+arr[i]
++++++++if+item+>+max_val:
++++++++++++max_val+=+item
++++++++elif+item+<+min_val:
++++++++++++min_val+=+item
++++result[0]+=+max_val
++++result[1]+=+min_val


def+extrema_loop_cy(arr):
++++result+=+np.zeros(2,+dtype=arr.dtype)
++++_extrema_loop_cy(arr,+arr.size,+result)
++++return+result[0],+result[1]|271414|%25%25cython+-c-O3+-c-march=native+-a
#cython:+language_level=3,+boundscheck=False,+wraparound=False,+initializedcheck=False,+cdivision=True,+infer_types=True


import+numpy+as+np


cdef+void+_extrema_while_cy(
++++++++long[:]+arr,
++++++++size_t+n,
++++++++long[:]+result):
++++cdef+size_t+i,+odd
++++cdef+long+x,+y,+max_val,+min_val
++++max_val+=+arr[0]
++++min_val+=+arr[0]
++++odd+=+n+%25+2
++++if+not+odd:
++++++++n+-=+1
++++max_val+=+min_val+=+arr[0]
++++i+=+1
++++while+i+<+n:
++++++++x+=+arr[i]
++++++++y+=+arr[i+%2B+1]
++++++++if+x+>+y:
++++++++++++x,+y+=+y,+x
++++++++min_val+=+min(x,+min_val)
++++++++max_val+=+max(y,+max_val)
++++++++i+%2B=+2
++++if+not+odd:
++++++++x+=+arr[n]
++++++++min_val+=+min(x,+min_val)
++++++++max_val+=+max(x,+max_val)
++++result[0]+=+max_val
++++result[1]+=+min_val


def+extrema_while_cy(arr):
++++result+=+np.zeros(2,+dtype=arr.dtype)
++++_extrema_while_cy(arr,+arr.size,+result)
++++return+result[0],+result[1]|271415|(+extrema_loop_*()方法类似于建议的here，而extrema_while_*()方法基于here的代码)|offset|length|style|CODE|271416|以下计时：|271417|​|271418|📷|atomic|271419|271420|表示extrema_while_*()最快，其中extrema_while_nb()最快。在任何情况下，extrema_loop_nb()和extrema_loop_cy()解决方案都优于仅使用NumPy的方法(分别使用np.max()和np.min()+)。|271421|最后，请注意，所有这些都不像np.min()/np.max()那样灵活(就n维支持、axis参数等而言)。|271422|(完整代码可在here上找到)|271423|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/33919126/5218354|1|https://stackoverflow.com/a/41733144/5218354|2|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/3fbf73050e9eea0b5fd666fbfbba72a6.png|imageAlt|3|https://colab.research.google.com/drive/1OH_G2hmSgS_NAMMwCafVSi9y1mIMoxd-^0|0|0|0|0|0|0|2|G|W|H|Q|4|0|1H|4|1|0|0|0|0|1|2|0|0|2|H|O|I|1G|H|1Y|H|32|8|3B|8|0|E|8|N|8|16|4|0|7|4|3|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|I|3|J|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1W|8|@$Q|1X|R|1Y|S|T]|$Q|1Z|R|20|S|T]]|9|@$Q|21|R|22|1|23]|$Q|24|R|25|1|26]]|A|$]]|$1|U|3|V|5|6|7|27|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|28|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|10|7|29|8|@]|9|@$Q|2A|R|2B|1|2C]]|A|$]]|$1|11|3|X|5|6|7|2D|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2E|8|@$Q|2F|R|2G|S|T]|$Q|2H|R|2I|S|T]|$Q|2J|R|2K|S|T]|$Q|2L|R|2M|S|T]|$Q|2N|R|2O|S|T]|$Q|2P|R|2Q|S|T]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2R|8|@$Q|2S|R|2T|S|T]|$Q|2U|R|2V|S|T]|$Q|2W|R|2X|S|T]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2Y|8|@]|9|@$Q|2Z|R|30|1|31]]|A|$]]|$1|18|3|-4|5|6|7|32|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]|1G|$5|1B|1C|1D|A|$1E|1H]]|1I|$5|1J|1C|1K|A|$1L|1M|1N|-4]]|1O|$5|1B|1C|1D|A|$1E|1P]]]]

Just to get some ideas on the numbers one could expect, given the following approaches:

<pre><code>import numpy as np


def extrema_np(arr):
 return np.max(arr), np.min(arr)
</code></pre>

<pre><code>import numba as nb


@nb.jit(nopython=True)
def extrema_loop_nb(arr):
 n = arr.size
 max_val = min_val = arr[0]
 for i in range(1, n):
 item = arr[i]
 if item &gt; max_val:
 max_val = item
 elif item &lt; min_val:
 min_val = item
 return max_val, min_val
</code></pre>

<pre><code>import numba as nb


@nb.jit(nopython=True)
def extrema_while_nb(arr):
 n = arr.size
 odd = n % 2
 if not odd:
 n -= 1
 max_val = min_val = arr[0]
 i = 1
 while i &lt; n:
 x = arr[i]
 y = arr[i + 1]
 if x &gt; y:
 x, y = y, x
 min_val = min(x, min_val)
 max_val = max(y, max_val)
 i += 2
 if not odd:
 x = arr[n]
 min_val = min(x, min_val)
 max_val = max(x, max_val)
 return max_val, min_val
</code></pre>

<pre><code>%%cython -c-O3 -c-march=native -a
#cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True, infer_types=True


import numpy as np


cdef void _extrema_loop_cy(
 long[:] arr,
 size_t n,
 long[:] result):
 cdef size_t i
 cdef long item, max_val, min_val
 max_val = arr[0]
 min_val = arr[0]
 for i in range(1, n):
 item = arr[i]
 if item &gt; max_val:
 max_val = item
 elif item &lt; min_val:
 min_val = item
 result[0] = max_val
 result[1] = min_val


def extrema_loop_cy(arr):
 result = np.zeros(2, dtype=arr.dtype)
 _extrema_loop_cy(arr, arr.size, result)
 return result[0], result[1]
</code></pre>

<pre><code>%%cython -c-O3 -c-march=native -a
#cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True, infer_types=True


import numpy as np


cdef void _extrema_while_cy(
 long[:] arr,
 size_t n,
 long[:] result):
 cdef size_t i, odd
 cdef long x, y, max_val, min_val
 max_val = arr[0]
 min_val = arr[0]
 odd = n % 2
 if not odd:
 n -= 1
 max_val = min_val = arr[0]
 i = 1
 while i &lt; n:
 x = arr[i]
 y = arr[i + 1]
 if x &gt; y:
 x, y = y, x
 min_val = min(x, min_val)
 max_val = max(y, max_val)
 i += 2
 if not odd:
 x = arr[n]
 min_val = min(x, min_val)
 max_val = max(x, max_val)
 result[0] = max_val
 result[1] = min_val


def extrema_while_cy(arr):
 result = np.zeros(2, dtype=arr.dtype)
 _extrema_while_cy(arr, arr.size, result)
 return result[0], result[1]
</code></pre>

(the <code>extrema_loop_*()</code> approaches are similar to what is proposed <a href="https://stackoverflow.com/a/33919126/5218354">here</a>, while <code>extrema_while_*()</code> approaches are based on the code from <a href="https://stackoverflow.com/a/41733144/5218354">here</a>)

The following timings:

<a href="https://i.stack.imgur.com/3rWX5.png" rel="noreferrer"><img src="https://i.stack.imgur.com/3rWX5.png" alt="bm"></a>

indicate that the <code>extrema_while_*()</code> are the fastest, with <code>extrema_while_nb()</code> being fastest. In any case, also the <code>extrema_loop_nb()</code> and <code>extrema_loop_cy()</code> solutions do outperform the NumPy-only approach (using <code>np.max()</code> and <code>np.min()</code> separately).

Finally, note that none of these is as flexible as <code>np.min()</code>/<code>np.max()</code> (in terms of n-dim support, <code>axis</code> parameter, etc.).

(full code is available <a href="https://colab.research.google.com/drive/1OH_G2hmSgS_NAMMwCafVSi9y1mIMoxd-" rel="noreferrer">here</a>)

blocks|key|271468|text|受previous+answer的启发，我编写了numba实现，从二维数组返回axis=0的minmax。它比调用numpy+min/max快大约5倍。也许有人会发现它很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|271469|from+numba+import+jit

@jit
def+minmax(x):
++++"""Return+minimum+and+maximum+from+2D+array+for+axis=0."""++++
++++m,+n+=+len(x),+len(x[0])
++++mi,+ma+=+np.empty(n),+np.empty(n)
++++mi[:]+=+ma[:]+=+x[0]
++++for+i+in+range(1,+m):
++++++++for+j+in+range(n):
++++++++++++if+x[i,+j]>ma[j]:+ma[j]+=+x[i,+j]
++++++++++++elif+x[i,+j]<mi[j]:+mi[j]+=+x[i,+j]
++++return+mi,+ma

x+=+np.random.normal(size=(256,+11))
mi,+ma+=+minmax(x)

np.all(mi+==+x.min(axis=0)),+np.all(ma+==+x.max(axis=0))
#+(True,+True)


%25timeit+x.min(axis=0),+x.max(axis=0)+
#+15.9+µs+±+9.4+ns+per+loop+(mean+±+std.+dev.+of+7+runs,+100000+loops+each)
%25timeit+minmax(x)+
#+2.62+µs+±+31.3+ns+per+loop+(mean+±+std.+dev.+of+7+runs,+100000+loops+each)|code-block|syntax|javascript|271470|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/33919126/632242^0|1|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Inspired by the <a href="https://stackoverflow.com/a/33919126/632242">previous answer</a> I've written numba implementation returning minmax for axis=0 from 2-D array. It's ~5x faster than calling numpy min/max.
Maybe someone will find it useful.
<pre><code>from numba import jit

@jit
def minmax(x):
 &quot;&quot;&quot;Return minimum and maximum from 2D array for axis=0.&quot;&quot;&quot; 
 m, n = len(x), len(x[0])
 mi, ma = np.empty(n), np.empty(n)
 mi[:] = ma[:] = x[0]
 for i in range(1, m):
 for j in range(n):
 if x[i, j]&gt;ma[j]: ma[j] = x[i, j]
 elif x[i, j]&lt;mi[j]: mi[j] = x[i, j]
 return mi, ma

x = np.random.normal(size=(256, 11))
mi, ma = minmax(x)

np.all(mi == x.min(axis=0)), np.all(ma == x.max(axis=0))
# (True, True)


%timeit x.min(axis=0), x.max(axis=0) 
# 15.9 µs ± 9.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit minmax(x) 
# 2.62 µs ± 31.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
</code></pre>

<a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.amax.html#numpy.amax" rel="noreferrer">numpy.amax()</a> will find the max value in an array, and <a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.amin.html" rel="noreferrer">numpy.amin()</a> does the same for the min value. If I want to find both max and min, I have to call both functions, which requires passing over the (very big) array twice, which seems slow.

Is there a function in the numpy API that finds both max and min with only a single pass through the data?

NumPy: function for simultaneous max() and min()

性能测试

编译器

Python

将在数组中查找最大值，而将对最小值执行相同的操作。如果我想同时找到max和min，我必须调用这两个函数，这需要对(非常大的)数组传递两次，这似乎很慢。numpy API中是否有一个函数只需一次遍历数据即可同时找到max和min？

问NumPy:同时使用max()和min()的函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NumPy:同时使用max()和min()的函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NumPy:同时使用max()和min()的函数
EN