it-swarm.com.ru

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

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

Например,

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

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

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

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

Для «правильного» способа посмотрите аргумент порядка ключевых слов 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'].

104
Joe Kington

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

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

551
Steve Tjoa

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

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.

22
J.J

Из вики документации 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]]]
17
user541064

Из списка рассылки 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]])
14
fgregg

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

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 является самым быстрым методом на сегодняшний день ...

13
MonkeyButter

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

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

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

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

Мое решение

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

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

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

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

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

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

3
xuma202

Немного более сложный пример lexsort - спуск по первому столбцу, вторичный подъём по второму. Уловки с 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]])
1
hpaulj

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

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