Le tri dans les tableaux NumPy par colonne

Comment trier un tableau NumPy par la n-ième colonne?

Par exemple,

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

Je voudrais trier les lignes par la deuxième colonne, telle que je serai de retour:

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

C'est vraiment un mauvais exemple puisque np.sort(a, axis=0) serait une solution satisfaisante pour la matrice donnée. J'ai proposé une modification avec un meilleur exemple, mais a été rejetée, même si effectivement, la question serait beaucoup plus clair. L'exemple doit être quelque chose comme a = numpy.array([[1, 2, 3], [6, 5, 2], [3, 1, 1]]) avec la sortie souhaitée array([[3, 1, 1], [1, 2, 3], [6, 5, 2]])
David, vous n'avez pas obtenir le point de la question. Il veut maintenir l'ordre au sein de chaque ligne de la même.

InformationsquelleAutor | 2010-05-13

119

@steves'est en fait la façon la plus élégante de le faire.

Pour la "bonne" façon de voir l'ordre argument mot-clé de numpy.ndarray.tri

Cependant, vous devez accéder à votre tableau comme un tableau avec des champs (un tableau structuré).

La "bonne" façon est assez laid si vous n'avez pas d'abord définir votre tableau avec des champs...

Comme un exemple rapide, de les trier et de renvoyer une copie:
```
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]])
```
De faire le tri sur place:
```
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 est vraiment la façon la plus élégante de le faire, autant que je sache...

Le seul avantage de cette méthode est que la "commande" de l'argument est une liste de champs à l'ordre de la recherche. Par exemple, vous pouvez trier les résultats par la deuxième colonne, puis la troisième colonne, puis la première colonne par la fourniture d'une commande=['f1','f2','f0'].
- Dans mon numpy 1.6.1rc1, il soulève ValueError: new type not compatible with array.
- Serait-il judicieux de déposer une demande de fonctionnalité que la "bonne" façon de rendre moins moche?
- Si les valeurs dans le tableau sont float? Dois-je changer quelque chose?
- Si vous avez transposé a avant d'arriver à ce point dans le code, vous aurez besoin de prendre une copie intégrale de manière à obtenir le bon sens de la view méthode. Voir cette quension.
- En réponse à @Marco question, vous pouvez utiliser a.dtype.str pour obtenir le 'i8' ou 'f8' chaîne...qui vous puis besoin de construire dans la chaîne délimitée par des virgules.
- Et pour type hybride comme a = np.array([['a',1,2,3],['b',4,5,6],['c',0,0,1]]) quelle démarche dois-je suivre?
- Sur cette base et de certains de vos autres commentaires, il semble que vous avez données avec un type commun dans chaque colonne (par exemple de type feuille de calcul des données). Si oui, jetez un oeil à pandas. Cela simplifiera beaucoup du type d'opération que vous souhaitez effectuer.
- Un avantage majeur de cette méthode sur Steve est qu'il permet de très grands tableaux triés en place. Pour un nombre suffisamment important de tableau, les indices retourné par np.argsort peuvent eux-mêmes prendre beaucoup de mémoire, et en plus de cela, l'indexation avec un tableau permettra également de générer une copie du tableau qui est en cours de tri.
- le type n'est pas compatible avec le tableau. peut aussi être causée par des valeurs NaN. Utilisation np.nan_to_num(a) à corriger.
- Comment modifier ce code pour obtenir de tri inverse?
- Merci pour le lien (deux ans plus tard...). Si array.flags.c_contiguous est vrai, c'est que la garantie que le point de vue méthode de travail?
InformationsquelleAutor Joe Kington
608

Je suppose que cela fonctionne: a[a[:,1].argsort()]

Cela indique la deuxième colonne de a et de tri sur la base en conséquence.
- Ce n'est pas clair, qu'est-ce que 1 ici? l'indice triées par?
- [:,1] indique la deuxième colonne de a.
- Si vous voulez l'inverse de tri, de modifier cela pour être a[a[:,1].argsort()[::-1]]
- L'air simple et ça marche! Est-il plus rapide que np.sort ou pas?
- Je trouve cela plus facile à lire: ind = np.argsort( a[:,1] ); a = a[ind]
- J'ai trouvé 1 peu déroutant, un[a[:,0].argsort()]
- Pour plus de solution générale qui permet de gérer les non-tableaux carrés, utilisation: a = array([[1,6,2],[5,3,7]]) print(a) c = a[0,:].argsort() print(c) d = a[:,c] print(d) c = a[:,1].argsort() print(c) e = a[c,:] print(e)
- un[a[:,k].argsort()] est le même que pour un[a[:,k].argsort(),:]. Cette généralise à l'autre dimension (sorte de cols, à l'aide d'une ligne): a[:,a[j,:].argsort()] (espoir j'ai tapé ce droit.)
- Aussi loin que je peux voir que cela ne se généralise pas pour le cas où l'on aurait envie de trier sur plusieurs colonnes cols, c'est à dire toutes les colonnes. Pour ce cas, je ne a[np.lexsort(a.T[cols])] où [cols] pourrait être laissé de côté si triés par toutes les colonnes et de droite à gauche. Cela permet aussi de définir l'ordre des colonnes pour trier, j'.e cols = range(a.shape[1])[::-1].
InformationsquelleAutor Steve Tjoa
23

Vous pouvez trier sur plusieurs colonnes comme par Steve Tjoa de la méthode en utilisant un tri stable comme mergesort et de trier les indices de la moins importante à la plus importante des colonnes:
```
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')]
```
Ce tris par colonne 0, puis 1, puis 2.
- Pourquoi ne Tri pas besoin d'être stable?
- Bonne question - stable signifie que lorsqu'il y a une cravate que vous conservez l'original de l'ordre, et l'ordre original des ménagères de fichier n'est pas pertinent.
- Cela semble vraiment un super point important. avoir une liste silencieusement ne serait mauvais.
InformationsquelleAutor J.J
19

De le wiki de documentation de Python, je pense que vous pouvez faire:
```
a = ([[1, 2, 3], [4, 5, 6], [0, 0, 1]]); 
a = sorted(a, key=lambda a_entry: a_entry[1]) 
print a
```
La sortie est:
```
[[[0, 0, 1], [1, 2, 3], [4, 5, 6]]]
```
- Avec cette solution, on obtient une liste au lieu d'un tableau NumPy, de sorte que cela peut ne pas toujours être pratique (prend plus de mémoire, est probablement plus lent, etc.).
InformationsquelleAutor user541064

Au cas où quelqu'un veut faire usage de tri à un moment critique de leurs programmes voici une comparaison des performances pour les différentes propositions:

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

Ainsi, il ressemble à de l'indexation avec argsort est la méthode la plus rapide pour l'instant...

InformationsquelleAutor prl900

De le NumPy liste de diffusion, voici une autre solution:

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

La bonne généralisation est a[np.lexsort(a.T[cols])]. où cols=[1] dans la question d'origine.

InformationsquelleAutor fgregg

4

J'ai eu un problème similaire.

Mon Problème:

Je veux calculer un SVD et le besoin de faire le tri dans mes les valeurs propres dans l'ordre décroissant. Mais je veux garder la correspondance entre les valeurs propres et vecteurs propres.
Mes valeurs propres étaient dans la première rangée et le vecteur propre correspondant ci-dessous dans la même colonne.

Si je veux trier un tableau à deux dimensions de la colonne de sage par la première rangée, dans l'ordre décroissant.

Ma Solution
```
a = a[::, a[0,].argsort()[::-1]]
```
Alors, comment cela fonctionne?

a[0,] est juste la première ligne, je veux trier par.

Maintenant, j'utilise argsort pour obtenir l'ordre des indices.

- Je utiliser [::-1] parce que j'ai besoin l'ordre décroissant.

Enfin je utiliser a[::, ...] pour obtenir une vue avec les colonnes dans le bon ordre.

InformationsquelleAutor xuma202

Un peu plus compliqué lexsort exemple - en descendant sur la 1ère colonne, secondairement ascendant sur le 2e. Les trucs avec lexsort sont sortes sur des lignes (d'où le .T), et donne la priorité à la dernière.

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

InformationsquelleAutor hpaulj

Voici une autre solution compte tenu de tous colonnes (façon plus compacte de J. J's réponse);

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

De tri avec lexsort,

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

De sortie:

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

InformationsquelleAutor Sefa

Vous devez vous connecter pour publier un commentaire.