6.12. Sélection et réorganisation#

Les réductions condensent un tableau en un scalaire ou un résultat de rang inférieur. La sélection couvre les opérations qui choisissent quels éléments survivent et où ils aboutissent : choix conditionnel, écrêtage, tri, recherche d’indices, réorganisation le long d’un axe.

6.12.1. Choix conditionnel#

where() renvoie un tableau qui prend les éléments de x là où la condition est vraie et de y sinon. Les trois opérandes sont diffusés ensemble

a = np.array([1, 2, 3, 4, 5], dtype=np.float)
np.where(a < 3, a, 0.0)
# array([1.0, 2.0, 0.0, 0.0, 0.0])

C’est l’outil idéal pour un « if/else par élément » sans écrire de boucle Python.

clip() est un raccourci pour maximum(lo, minimum(a, hi)) – saturer les valeurs dans une plage

np.clip(a, 2.0, 4.0)
# array([2.0, 2.0, 3.0, 4.0, 4.0])

maximum() et minimum() prennent deux opérandes et renvoient le plus grand / plus petit élément par élément

np.maximum(a, 3.0)
np.minimum(a, np.array([5, 4, 3, 2, 1]))

6.12.2. Recherche d’indices#

nonzero() renvoie les coordonnées de chaque élément non nul, réparties en un tableau d’indices par dimension. Pour une entrée 2-D, le résultat est un tuple de deux tableaux : le premier contient les indices de ligne, le second les indices de colonne. En les appariant colonne par colonne, on obtient le (row, col) de chaque position non nulle

m = np.array([[0, 2, 0],
              [3, 0, 0]], dtype=np.float)
np.nonzero(m)
# (array([0, 1], dtype=uint16), array([1, 0], dtype=uint16))

Les entrées non nulles de m sont m[0, 1] = 2 et m[1, 0] = 3. Le premier tableau renvoyé [0, 1] donne leurs indices de ligne ; le second [1, 0] donne leurs indices de colonne. Lire les deux tableaux côte à côte permet de retrouver les positions (0, 1) et (1, 0).

Deux réductions produisent également des indices :

argmin() / argmax() – indice du plus petit / plus grand élément.
argsort() – un tableau d’entiers qui trierait l’entrée le long de l’axe donné (le dernier par défaut)
```
a = np.array([40, 10, 30, 20], dtype=np.uint8)
idx = np.argsort(a)             # array([1, 3, 2, 0], dtype=uint16)
a[idx]                          # array([10, 20, 30, 40])
```
argsort renvoie toujours des uint16 ; le tableau trié ne doit donc pas comporter plus de 65 535 éléments sur l’axe trié.

bincount() compte les occurrences de chaque entier non négatif dans une entrée 1-D uint8 / uint16

histogram = np.bincount(np.array([0, 1, 1, 2, 2, 2], dtype=np.uint8))
# array([1, 2, 3], dtype=uint16)

Utile pour construire des histogrammes de valeurs de pixels à petits entiers sans écrire de boucle Python.

6.12.3. Tri et réorganisation#

sort() renvoie une copie triée du tableau le long de l’axe donné (le dernier par défaut). Utilisez sort() directement sur le tableau pour une version sur place

np.sort(np.array([3, 1, 2], dtype=np.float))
# array([1.0, 2.0, 3.0])

flip() inverse l’ordre le long de l’axe donné (tous les axes lorsqu’aucun axis n’est passé)

np.flip(np.array([1, 2, 3, 4]))
# array([4, 3, 2, 1])

roll() décale cycliquement les éléments du nombre donné. Utile pour implémenter un registre à décalage de type tampon circulaire

np.roll(np.array([1, 2, 3, 4]), 1)
# array([4, 1, 2, 3])

take() est la forme explicite de l’indexation avancée – choisir des éléments à des indices arbitraires

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.take(a, [0, 2, 4])
# array([10, 30, 50], dtype=uint8)

6.12.4. Filtrage et modifications structurelles#

compress() est la forme explicite de l’indexation booléenne – renvoie les tranches de a sélectionnées par la condition booléenne

a = np.array([10, 20, 30, 40], dtype=np.uint8)
np.compress(a > 15, a)
# array([20, 30, 40], dtype=uint8)

delete() renvoie une copie dont les entrées aux indices donnés sont supprimées

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.delete(a, [1, 3])
# array([10, 30, 50], dtype=uint8)

diff() renvoie la n-ième différence avant discrète du tableau le long d’un axe. Utilisé pour calculer les variations du premier ordre entre échantillons adjacents

samples = np.array([1, 3, 6, 10, 15], dtype=np.float)
np.diff(samples)
# array([2.0, 3.0, 4.0, 5.0])

6.12.5. Le coût de chaque opération#

Presque toutes les fonctions de cette page renvoient un tableau fraîchement alloué. Deux exceptions :

sort() trie sur place ; la fonction libre sort() renvoie une copie triée.
take() accepte un mot-clé out= pour écrire dans un tampon déjà existant.

Dans une boucle qui s’exécute plusieurs fois par seconde, préférez le tri sur place sort() et réutilisez des tampons pré-alloués partout ailleurs. Les masques booléens eux-mêmes sont alloués à chaque exécution de la comparaison – construisez un masque une seule fois et réutilisez-le entre les opérations plutôt que de le reconstruire à chaque itération.