Сортировка массивов в NumPy по столбцам

Как я могу отсортировать массив в NumPy по n-му столбцу?

Например,

a = array([[9, 2, 3],
           [4, 5, 6],
           [7, 0, 5]])

Я хотел бы отсортировать строки по второму столбцу, чтобы я вернулся:

array([[7, 0, 5],
       [9, 2, 3],
       [4, 5, 6]])

@steve «s ответ на самом деле самый элегантный способ сделать это.

Для «правильного» способа смотрите аргумент порядка ключевых слов numpy.ndarray.sort

Тем не менее, вам нужно будет просматривать ваш массив как массив с полями (структурированный массив).

«Правильный» способ довольно уродлив, если вы изначально не определяли свой массив с полями ...

В качестве быстрого примера, чтобы отсортировать его и вернуть копию:

In [1]: import numpy as np

In [2]: a = np.array([[1,2,3],[4,5,6],[0,0,1]])

In [3]: np.sort(a.view('i8,i8,i8'), order=['f1'], axis=0).view(np.int)
Out[3]: 
array([[0, 0, 1],
       [1, 2, 3],
       [4, 5, 6]])

Чтобы отсортировать на месте:

In [6]: a.view('i8,i8,i8').sort(order=['f1'], axis=0) #<-- returns None

In [7]: a
Out[7]: 
array([[0, 0, 1],
       [1, 2, 3],
       [4, 5, 6]])

@ Насколько мне известно, Стив - самый элегантный способ сделать это ...

Единственное преимущество этого метода заключается в том, что аргумент «порядок» - это список полей, по которым нужно упорядочить поиск. Например, вы можете отсортировать по второму столбцу, затем по третьему столбцу, затем по первому столбцу, указав order = ['f1', 'f2', 'f0'].

Я полагаю, это работает: a[a[:,1].argsort()]

Это указывает на второй столбец aи сортирует его по нему соответственно.

Вы можете сортировать по нескольким столбцам согласно методу Стива Тджоа, используя стабильную сортировку, такую ​​как сортировка слиянием, и сортируя индексы от наименее значимых к наиболее значимым столбцам:

a = a[a[:,2].argsort()] # First sort doesn't need to be stable.
a = a[a[:,1].argsort(kind='mergesort')]
a = a[a[:,0].argsort(kind='mergesort')]

Это сортирует по столбцу 0, затем 1, затем 2.

В случае, если кто-то хочет использовать сортировку в критической части своих программ, вот сравнение производительности для различных предложений:

import numpy as np
table = np.random.rand(5000, 10)

%timeit table.view('f8,f8,f8,f8,f8,f8,f8,f8,f8,f8').sort(order=['f9'], axis=0)
1000 loops, best of 3: 1.88 ms per loop

%timeit table[table[:,9].argsort()]
10000 loops, best of 3: 180 µs per loop

import pandas as pd
df = pd.DataFrame(table)
%timeit df.sort_values(9, ascending=True)
1000 loops, best of 3: 400 µs per loop

Итак, похоже, что индексация с помощью argsort является самым быстрым методом на сегодняшний день ...

Из документации вики Python , я думаю , что вы можете сделать:

a = ([[1, 2, 3], [4, 5, 6], [0, 0, 1]]); 
a = sorted(a, key=lambda a_entry: a_entry[1]) 
print a

Выход:

[[[0, 0, 1], [1, 2, 3], [4, 5, 6]]]

Из списка рассылки NumPy есть еще одно решение:

>>> a
array([[1, 2],
       [0, 0],
       [1, 0],
       [0, 2],
       [2, 1],
       [1, 0],
       [1, 0],
       [0, 0],
       [1, 0],
      [2, 2]])
>>> a[np.lexsort(np.fliplr(a).T)]
array([[0, 0],
       [0, 0],
       [0, 2],
       [1, 0],
       [1, 0],
       [1, 0],
       [1, 0],
       [1, 2],
       [2, 1],
       [2, 2]])

У меня была похожая проблема.

Моя проблема:

Я хочу рассчитать SVD и нужно отсортировать мои собственные значения в порядке убывания. Но я хочу сохранить соответствие между собственными значениями и собственными векторами. Мои собственные значения были в первом ряду, а соответствующий собственный вектор - в том же столбце.

Поэтому я хочу отсортировать двумерный массив по столбцам по первой строке в порядке убывания.

Мое решение

a = a[::, a[0,].argsort()[::-1]]

Так, как это работает?

a[0,] это только первый ряд, по которому я хочу отсортировать.

Теперь я использую argsort для получения порядка индексов.

Я использую, [::-1]потому что мне нужно в порядке убывания.

Наконец, я использую, a[::, ...]чтобы получить представление со столбцами в правильном порядке.

Немного более сложный lexsortпример - спуск по 1-му столбцу, второй по возрастанию по 2-му. Хитрости в том lexsort, что он сортирует по строкам (отсюда и .T) и отдает приоритет последним.

In [120]: b=np.array([[1,2,1],[3,1,2],[1,1,3],[2,3,4],[3,2,5],[2,1,6]])
In [121]: b
Out[121]: 
array([[1, 2, 1],
       [3, 1, 2],
       [1, 1, 3],
       [2, 3, 4],
       [3, 2, 5],
       [2, 1, 6]])
In [122]: b[np.lexsort(([1,-1]*b[:,[1,0]]).T)]
Out[122]: 
array([[3, 1, 2],
       [3, 2, 5],
       [2, 1, 6],
       [2, 3, 4],
       [1, 1, 3],
       [1, 2, 1]])

Вот еще одно решение, учитывающее все столбцы (более компактный способ ответа JJ );

ar=np.array([[0, 0, 0, 1],
             [1, 0, 1, 0],
             [0, 1, 0, 0],
             [1, 0, 0, 1],
             [0, 0, 1, 0],
             [1, 1, 0, 0]])

Сортировка с помощью lexsort,

ar[np.lexsort(([ar[:, i] for i in range(ar.shape[1]-1, -1, -1)]))]

Вывод:

array([[0, 0, 0, 1],
       [0, 0, 1, 0],
       [0, 1, 0, 0],
       [1, 0, 0, 1],
       [1, 0, 1, 0],
       [1, 1, 0, 0]])

Просто используя сортировку, используйте номер столбца, по которому вы хотите отсортировать.

a = np.array([1,1], [1,-1], [-1,1], [-1,-1]])
print (a)
a=a.tolist() 
a = np.array(sorted(a, key=lambda a_entry: a_entry[0]))
print (a)

Это старый вопрос, но если вам нужно обобщить это для массивов с размерами выше 2, вот решение, которое можно легко обобщить:

np.einsum('ij->ij', a[a[:,1].argsort(),:])

Это избыточное решение для двух измерений, и a[a[:,1].argsort()]этого будет достаточно для ответа @ steve, однако этот ответ нельзя обобщить для более высоких измерений. Вы можете найти пример трехмерного массива в этом вопросе.

Вывод:

[[7 0 5]
 [9 2 3]
 [4 5 6]]