Ordinamento di matrici in NumPy per colonna

Come posso ordinare un array in NumPy dall'ennesima colonna?

Per esempio,

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

Vorrei ordinare le righe in base alla seconda colonna, in modo da tornare indietro:

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

La risposta di @steve è in realtà il modo più elegante di farlo.

Per il modo "corretto", consultare l'argomento della parola chiave order di numpy.ndarray.sort

Tuttavia, dovrai visualizzare il tuo array come un array con campi (un array strutturato).

Il modo "corretto" è abbastanza brutto se inizialmente non hai definito l'array con i campi ...

A titolo di esempio, per ordinarlo e restituire una copia:

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

Per ordinarlo sul posto:

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

@ Steve è davvero il modo più elegante per farlo, per quanto ne so ...

L'unico vantaggio di questo metodo è che l'argomento "ordine" è un elenco dei campi per cui ordinare la ricerca. Ad esempio, è possibile ordinare in base alla seconda colonna, quindi alla terza colonna, quindi alla prima colonna fornendo order = ['f1', 'f2', 'f0'].

Suppongo che funzioni: a[a[:,1].argsort()]

Questo indica la seconda colonna ae la ordina in base ad essa di conseguenza.

Puoi ordinare su più colonne secondo il metodo di Steve Tjoa usando un ordinamento stabile come mergesort e ordinando gli indici dalle colonne meno significative a quelle più significative:

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

Questo ordina per colonna 0, quindi 1, quindi 2.

Nel caso in cui qualcuno desideri utilizzare l'ordinamento in una parte critica dei propri programmi, ecco un confronto delle prestazioni per le diverse proposte:

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

Quindi, sembra che l'indicizzazione con argsort sia il metodo più veloce finora ...

Dal wiki della documentazione di Python , penso che tu possa fare:

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

L'output è:

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

Dalla mailing list di NumPy , ecco un'altra soluzione:

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

Ho avuto un problema simile.

Il mio problema:

Voglio calcolare un SVD e ho bisogno di ordinare i miei autovalori in ordine decrescente. Ma voglio mantenere la mappatura tra autovalori e autovettori. I miei autovalori erano nella prima riga e il corrispondente autovettore sotto di esso nella stessa colonna.

Quindi voglio ordinare un array bidimensionale per colonna secondo la prima riga in ordine decrescente.

La mia soluzione

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

Quindi come funziona?

a[0,] è solo la prima riga che voglio ordinare.

Ora utilizzo argsort per ottenere l'ordine degli indici.

Uso [::-1]perché ho bisogno di un ordine decrescente.

Infine, utilizzo a[::, ...]per ottenere una vista con le colonne nell'ordine giusto.

Un lexsortesempio un po 'più complicato : scendendo sulla 1a colonna, salendo secondariamente sulla 2a. I trucchi con lexsortsono che ordina sulle righe (da qui il .T) e dà la priorità all'ultimo.

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

Ecco un'altra soluzione considerando tutte le colonne (modo più compatto della risposta di 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]])

Ordina con lexsort,

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

Produzione:

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

Semplicemente usando l'ordinamento, utilizzare il numero di colonna in base al quale si desidera ordinare.

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)

È una vecchia domanda, ma se è necessario generalizzare questo in array di dimensioni superiori a 2, ecco la soluzione che può essere facilmente generalizzata:

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

Questo è un eccesso per due dimensioni e a[a[:,1].argsort()]sarebbe sufficiente per la risposta di @ steve, tuttavia quella risposta non può essere generalizzata a dimensioni superiori. Potete trovare un esempio di array 3D in questa domanda.

Produzione:

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