Tôi ngạc nhiên vì câu hỏi cụ thể này chưa từng được hỏi trước đây, nhưng tôi thực sự không tìm thấy nó trên SO cũng như trên tài liệu của np.sort.

Giả sử tôi có một mảng numpy ngẫu nhiên chứa các số nguyên, ví dụ:

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

Nếu tôi sắp xếp nó, tôi nhận được thứ tự tăng dần theo mặc định:

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

nhưng tôi muốn giải pháp được sắp xếp theo thứ tự giảm dần .

Bây giờ, tôi biết tôi luôn có thể làm:

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

nhưng câu lệnh cuối cùng này có hiệu quả không? Nó không tạo một bản sao theo thứ tự tăng dần, và sau đó đảo ngược bản sao này để nhận được kết quả theo thứ tự đảo ngược? Nếu điều này thực sự xảy ra, có một giải pháp thay thế hiệu quả không? Nó không giống như np.sortchấp nhận các tham số để thay đổi dấu hiệu của các phép so sánh trong thao tác sắp xếp để đưa mọi thứ theo thứ tự ngược lại.

temp[::-1].sort()sắp xếp mảng tại chỗ, ngược lại np.sort(temp)[::-1]tạo một mảng mới.

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])

Đối với mảng ngắn, tôi khuyên bạn nên sử dụng bằng np.argsort()cách tìm các chỉ số của mảng phủ định đã sắp xếp, nhanh hơn một chút so với việc đảo ngược mảng đã sắp xếp:

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

Thật không may khi bạn có một mảng phức tạp, chỉ np.sort(temp)[::-1]hoạt động đúng cách. Hai phương pháp khác được đề cập ở đây không hiệu quả.

Hãy cẩn thận với các kích thước.

Để cho

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

Đảo ngược hoàn toàn

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

• flipđã thay đổi 1.15, cần có phiên bản trước . Giải pháp: .1.14 axispip install --upgrade numpy

Thứ nguyên đầu tiên được đảo ngược

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

Thứ nguyên thứ hai được đảo ngược

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

Thử nghiệm

Thử nghiệm trên mảng 100 × 10 × 10 1000 lần.

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

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

Điều này chủ yếu là do lập chỉ mục lại chứ không phải 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()], xs)
timeit(lambda x: x.sort(), xs)
timeit(lambda x: x.argsort(), xs)
timeit(lambda x: np.flip(x), xs)

Xin chào Tôi đang tìm kiếm một giải pháp để sắp xếp ngược lại một mảng numpy hai chiều và tôi không thể tìm thấy bất kỳ thứ gì hiệu quả, nhưng tôi nghĩ rằng tôi đã vấp phải một giải pháp mà tôi đang tải lên để đề phòng bất kỳ ai ở cùng thuyền.

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

np.sort sắp xếp tăng dần không phải là những gì bạn muốn, nhưng lệnh flipplr lật các hàng từ trái sang phải! Có vẻ hiệu quả!

Hy vọng nó giúp được bạn!

Tôi đoán nó tương tự như đề xuất về -np.sort (-a) ở trên nhưng tôi đã bị tạm dừng vì nhận xét rằng nó không phải lúc nào cũng hoạt động. Có lẽ giải pháp của tôi cũng không phải lúc nào cũng hoạt động, tuy nhiên tôi đã thử nghiệm nó với một vài mảng và có vẻ ổn.

Bạn có thể sắp xếp mảng trước (Tăng dần theo mặc định) và sau đó áp dụng np.flip () ( https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html )

FYI Nó cũng hoạt động với các đối tượng datetime.

Thí dụ:

    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])

Đây là một mẹo nhanh

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]

tôi đề nghị sử dụng cái này ...

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

ví dụ:

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

Sau đó, resault của bạn:

[ 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. ]