numpy 배열을 내림차순으로 효율적으로 정렬하시겠습니까?

numpy 배열을 내림차순으로 효율적으로 정렬하시겠습니까?

는 이 되지 않았다는 , 저는 np.sort.

예를 들어, 정수를 포함하는 임의의 numpy 배열이 있다고 가정합니다.

> temp = np.random.randint(1,10, 10)    
> temp
array([2, 4, 7, 4, 2, 2, 7, 6, 4, 4])

정렬하면 기본적으로 오름차순이 표시됩니다.

> np.sort(temp)
array([2, 2, 2, 4, 4, 4, 4, 6, 7, 7])

하지만 저는 솔루션이 내림차순으로 정렬되기를 원합니다.

이제, 저는 항상 할 수 있습니다.

reverse_order = np.sort(temp)[::-1]

하지만 이 마지막 진술이 효율적인가요?그것은 오름차순으로 복사본을 만든 다음 이 복사본을 거꾸로 만들어서 결과를 역순으로 얻는 것이 아닙니까?정말 그렇다면 효율적인 대안이 있을까요?그렇게 보이지 않습니다.np.sort에서는 매개 변수를 사용하여 정렬 작업에서 비교 부호를 변경하여 순서를 역순으로 지정합니다.

temp[::-1].sort()에, 배을제자정렬반는면하에리열,반▁in면▁sorts▁the▁array▁whereas배열는,.np.sort(temp)[::-1]새 배열을 만듭니다.

In [25]: temp = np.random.randint(1,10, 10)

In [26]: temp
Out[26]: array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4])

In [27]: id(temp)
Out[27]: 139962713524944

In [28]: temp[::-1].sort()

In [29]: temp
Out[29]: array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2])

In [30]: id(temp)
Out[30]: 139962713524944

>>> a=np.array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4])

>>> np.sort(a)
array([2, 2, 4, 4, 4, 4, 5, 6, 7, 8])

>>> -np.sort(-a)
array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2])

짧은 어레이의 경우 사용을 사용하는 것이 좋습니다.np.argsort()정렬된 음의 배열의 인덱스를 찾음으로써 정렬된 배열을 반전시키는 것보다 약간 빠릅니다.

In [37]: temp = np.random.randint(1,10, 10)

In [38]: %timeit np.sort(temp)[::-1]
100000 loops, best of 3: 4.65 µs per loop

In [39]: %timeit temp[np.argsort(-temp)]
100000 loops, best of 3: 3.91 µs per loop

치수에 주의하십시오.

허락하다

x  # initial numpy array
I = np.argsort(x) or I = x.argsort() 
y = np.sort(x)    or y = x.sort()
z  # reverse sorted array

풀 리버스

z = x[I[::-1]]
z = -np.sort(-x)
z = np.flip(y)

• flip 변경됨, 이전 버전 필요 axis 솔션:pip install --upgrade numpy.

첫 번째 치수가 반전됨

z = y[::-1]
z = np.flipud(y)
z = np.flip(y, axis=0)

2차원 역방향

z = y[::-1, :]
z = np.fliplr(y)
z = np.flip(y, axis=1)

테스트

100×10×10 어레이에서 1000회 테스트.

Method       | Time (ms)
-------------+----------
y[::-1]      | 0.126659  # only in first dimension
-np.sort(-x) | 0.133152
np.flip(y)   | 0.121711
x[I[::-1]]   | 4.611778

x.sort()     | 0.024961
x.argsort()  | 0.041830
np.flip(x)   | 0.002026

이는 주로 재색인 때문이지,argsort.

# Timing code
import time
import numpy as np


def timeit(fun, xs):
    t = time.time()
    for i in range(len(xs)):  # inline and map gave much worse results for x[-I], 5*t
        fun(xs[i])
    t = time.time() - t
    print(np.round(t,6))

I, N = 1000, (100, 10, 10)
xs = np.random.rand(I,*N)
timeit(lambda x: np.sort(x)[::-1], xs)
timeit(lambda x: -np.sort(-x), xs)
timeit(lambda x: np.flip(x.sort()), xs)
timeit(lambda x: x[x.argsort()[::-1]], xs)
timeit(lambda x: x.sort(), xs)
timeit(lambda x: x.argsort(), xs)
timeit(lambda x: np.flip(x), xs)

np.flip()역인덱스와 역인덱스는 기본적으로 동일합니다.다음은 세 가지 다른 방법을 사용한 벤치마크입니다.인것 같습니다np.flip()조금 더 빠릅니다.부정을 사용하는 것은 두 번 사용하기 때문에 더 느리기 때문에 배열을 반대로 하는 것이 더 빠릅니다.

:np.flip()보다 .np.fliplr()내 테스트에 의하면

def sort_reverse(x):
    return np.sort(x)[::-1]

def sort_negative(x):
    return -np.sort(-x)

def sort_flip(x):
    return np.flip(np.sort(x)) 

arr=np.random.randint(1,10000,size=(1,100000))

%timeit sort_reverse(arr)
%timeit sort_negative(arr)
%timeit sort_flip(arr)

결과는 다음과 같습니다.

6.61 ms ± 67.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
6.69 ms ± 64.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
6.57 ms ± 58.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

안녕하세요. 2차원 numpy 배열을 역순으로 정렬할 수 있는 솔루션을 찾고 있었는데 작동하는 것을 찾을 수 없었습니다. 하지만 누군가 같은 보트에 있을 경우를 대비하여 업로드하는 솔루션을 우연히 발견한 것 같습니다.

x=np.sort(array)
y=np.fliplr(x)

np.sort오름차순이 오름차순으로 합니다.fliplr행을 왼쪽에서 오른쪽으로 뒤집습니다!효과가 있는 것 같습니다!

도움이 되길 바랍니다!

제 생각에 그것은 에 대한 제안과 비슷할 것 같습니다.-np.sort(-a)위에 언급했지만 항상 효과가 있는 것은 아니라는 댓글 때문에 저는 그것을 미루었습니다.제 솔루션도 항상 작동하지는 않겠지만, 몇 개의 어레이로 테스트해 본 결과 문제가 없는 것 같습니다.

안타깝게도 복잡한 배열을 가지고 있을 때만np.sort(temp)[::-1]제대로 작동합니다.여기에 언급된 다른 두 가지 방법은 효과적이지 않습니다.

먼저 배열을 정렬한 다음(기본적으로 오름차순) np.dll을 적용할 수 있습니다(https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html)

참고로, 이것은 날짜/시간 객체와도 작동합니다.

예:

    x = np.array([2,3,1,0]) 
    x_sort_asc=np.sort(x) 
    print(x_sort_asc)

    >>> array([0, 1, 2, 3])

    x_sort_desc=np.flip(x_sort_asc) 
    print(x_sort_desc)

    >>> array([3,2,1,0])

여기 빠른 속임수가 있습니다.

In[3]: import numpy as np
In[4]: temp = np.random.randint(1,10, 10)
In[5]: temp
Out[5]: array([5, 4, 2, 9, 2, 3, 4, 7, 5, 8])

In[6]: sorted = np.sort(temp)
In[7]: rsorted = list(reversed(sorted))
In[8]: sorted
Out[8]: array([2, 2, 3, 4, 4, 5, 5, 7, 8, 9])

In[9]: rsorted
Out[9]: [9, 8, 7, 5, 5, 4, 4, 3, 2, 2]

사용할 수 있습니다.sort에서 기능.numpy:

array = np.random.rand(10) 
rev_sort = -np.sort(-array)

저는 이것을 사용하는 것을 제안합니다.

np.arange(start_index, end_index, intervals)[::-1]

예:

np.arange(10, 20, 0.5)
np.arange(10, 20, 0.5)[::-1]

그러면 당신의 보복:

[ 19.5,  19. ,  18.5,  18. ,  17.5,  17. ,  16.5,  16. ,  15.5,
    15. ,  14.5,  14. ,  13.5,  13. ,  12.5,  12. ,  11.5,  11. ,
    10.5,  10. ]

언급URL : https://stackoverflow.com/questions/26984414/efficiently-sorting-a-numpy-array-in-descending-order