Indexation et tris en numpy

Sélection d'une partie d'une array : si ar est une array 2d (par exemple ar = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) :

ar[1:3,0:2] : récupère la sous-array des lignes 2 et 3, et des colonnes 1 et 2.
attention : l'array récupérée est une vue : si on la modifie, cela modifie l'array d'origine !
ar[1,:] : renvoie la 2ème ligne, mais l'array renvoyée n'a plus qu'une seule dimension ! (par contre, ar[1:2,:] renvoie aussi la 2ème ligne, mais en conservant les 2 dimensions)
ar[:,-1] : renvoie la dernière colonne.
ar[numpy.newaxis,2,:] : renvoie la 2ème ligne en conservant la première dimension (shape vaut ici (1, 3))
ar[:,-1,numpy.newaxis].shape : renvoie la dernière colonne en conservant la 2ème dimension (shape vaut ici (3, 1))

Sélection dans une array 2d de lignes et/ou colonnes non consécutives :

ar[numpy.ix_([0, 2], [3, 4])] : récupère le tableau 2x2 avec les lignes 1 et 3, et les colonnes 4 et 5.
l'array récupérée est totalement indépendante de l'array d'origine, contrairement à ce qui se passe quand on fait ar[0:3,3:5] !

Pour conserver toutes les lignes ou colonnes sauf une d'une array 2d :

numpy.delete(ar, 2, axis = 0) : renvoie une array sans la 3ème ligne (retourne une copie indépendante). 0 est l'axis.
numpy.delete(ar, 2, axis = 1) : renvoie une array sans la 3ème colonne (retourne une copie indépendante). 1 est l'axis.
numpy.delete(ar, [0, 2], axis = 0) : renvoie une array sans les lignes 1 et 3.
pour une array 1d : numpy.delete(ar, [1, 4]) : renvoie une array sans les index indiqués.

Génération d'index selon certains critères :

si a = numpy.array([[1, 2, 0], [4, 0, 6], [0, 0, 0]]) :

array([[1, 2, 0],
       [4, 0, 6],
       [0, 0, 0]])

numpy.nonzero(a) : les indices où la valeur est non nulle, donc ici (array([0, 0, 1, 1]), array([0, 1, 0, 2])).
numpy.where(a == 0) : renvoie un tuple avec comme nombre d'éléments le nombre de dimensions de a. Si a est un vecteur 1d, renvoie un tuple à un seul élément, à savoir les indices où la condition est vraie, c'est à dire ici (array([0, 1, 2, 2, 2]), array([2, 1, 0, 1, 2])) (numpy.where(a != 0) revient à numpy.nonzero(a)).
numpy.where(a == 0, 0, 1) : renvoie une array de même dimension que a avec 0 si la condition est vraie, 1 si la condition est fausse, c'est à dire :
```
array([[1, 1, 0],
       [1, 0, 1],
       [0, 0, 0]])
    
```
numpy.where(a == 0, -1, a) : renvoie une array avec -1 si la condition est vraie, sinon la valeur de a à la même position :
```
array([[ 1,  2, -1],
       [ 4, -1,  6],
       [-1, -1, -1]])
    
```
numpy.where((a > 0) & (a < 100)) (les opérateurs booléens sont & | et ~). Attention, il faut absolument mettre des parenthèses !
pour une array 1d : a[numpy.where(a != 0)] renvoie une array des valeurs différentes de 0 de a.
a[numpy.where(a == 0)] = -1 : met -1 dans a à toutes les positions où il y avait 0, donc donne :
```
array([[ 1,  2, -1],
       [ 4, -1,  6],
       [-1, -1, -1]])
    
```
ar = numpy.array([3, 8, 4, 7, 4, 9]); numpy.argwhere([ar > 7])[:,1] : renvoie les indices où la condition est vraie.
numpy.diag_indices(3) : renvoie les indices de la diagonale d'une matrice 3 x 3, c'est à dire (array([0, 1, 2]), array([0, 1, 2])). On peut alors faire : a[numpy.diag_indices(3)] = 7 pour mettre des 7 sur la diagonale.
numpy.tril_indices(3) : renvoie les indices du triangle inférieur d'une matrice 3 x 3, diagonale comprise. Idem avec numpy.triu_indices(3) pour la partie supérieure.

Selection de lignes : ar[(ar > 2) & (ar < 8)] : renvoie une array avec les valeurs satisfaisant la condition

Autres recherche d'indices :

On utilise ici a = numpy.array([[2, 5, 8], [3, 6, 4]]), donc :
```
array([[2, 5, 8],
       [3, 6, 4]])
    
```
numpy.argmin(a, 0) : recherche des numéros de lignes ayant la valeur minimale sur la colonne, donc ici array([0, 0, 1]). Idem avec numpy.argmax(a, 0).

Tri :

On utilise ici a = numpy.array([[2, 5, 8], [3, 6, 4]]), donc :
```
array([[2, 5, 8],
       [3, 6, 4]])
    
```
numpy.sort(a, 0) : renvoie une array avec un tri croissant par colonne, donne ici :
```
array([[2, 5, 4],
       [3, 6, 8]])
    
```
numpy.sort(a, 1) : renvoie une array avec un tri croissant par ligne, donne ici :
```
array([[2, 5, 8],
       [3, 4, 6]])
    
```

Récupération de l'ordre de tri :

si a = numpy.array([5, 3, 4, 3, 5]), on peut récupérer l'ordre des index qui permettrait le tri par : numpy.argsort(a) ou a.argsort() (donne ici array([1, 3, 2, 0, 4])).
on peut alors récupérer l'array triée par a[a.argsort()] ou trier n'importe quelle autre array de même taille.
attention : on peut donner l'algorithme de tri à utiliser et c'est quicksort par défaut (non stable) : a.argsort(kind = 'quicksort'). Ca peut être 'quicksort', 'mergesort' ou 'heapsort', mais seul mergesort est stable : il respecte l'ordre de clefs identiques (mais il n'est pas en place contrairement aux autres).
on peut aussi utiliser : numpy.lexsort((a,)) qui renvoie array([1, 3, 2, 0, 4]) et lui, il est garanti stable !
avec lexsort, on peut trier sur plusieurs clefs, d'abord a1, puis en cas d'égalité a2, etc ..., mais attention, il faut les donner dans l'ordre inverse : a1 = numpy.array([5, 3, 4, 3, 5]); a2 = numpy.array([3, 8, 2, 0, 1]); numpy.lexsort((a2, a1)) : donne array([3, 1, 2, 4, 0])

programmer en python, tutoriel python, graphes en python, Aymeric Duclert