Remarque : la longueur d'un array est toujours supérieure d'une unité à l'indice le plus élevé de l'array.
Remarque : la méthode remove() de la liste ne supprime que la première occurrence de la valeur spécifiée.
Remarque : Python n'a pas de support intégré pour les arrays, mais les listes Python peuvent être utilisées à la place.
.
Un array 1-D est créé comme un vecteur.
Récupérer la dimension d'un array
Pour connaitre le nombre de dimensions d'un array, la propriété ndim est utilisée. En NumPy, les dimensions sont appelées axes.
Par exemple : le code qui suit renvoie la dimension de l'array:
📋 Copier le code
import numpy as np
a = np.array([1, 2, 3])
x= a.ndim
if x ==1:
print("l'array a une dimension")
else:
print("l'array a " + str(x) + " dimensions")
Dans cet exemple, la propriété ndim renvoie 1 .
Obtention du type de données des éléments d'un array
Pour obtenir le type de données des éléments d'un array, vous utilisez la propriété dtype.
Par exemple :
📋 Copier le code
import numpy as np
a = np.array([1, 2, 3])
print(a.dtype)
Dans cet exemple, le type des éléments est int32.
Si vous voulez définir le type des éléments de l'array, vous pouvez utiliser l'argument dtype de la fonction array().
Comme le montre l'exemple xuivant :
📋 Copier le code
import numpy as np
a = np.array([1, 2, 3], dtype=np.float64)
print(a)
print(a.dtype)
Dans cet exemple, les nombres de l'array ont le point décimal (.) et le type de données de ses éléments est float64.
Indexation de arrays 1-D NumPy
Le long d'un seul axe, vous pouvez sélectionner des éléments en utilisant des indices. Le premier élément est indexé 0, le deuxième élément est indexé 1, et ainsi de suite.
Outre les indices non négatifs, vous pouvez utiliser des indices négatifs pour localiser des éléments. Par exemple, le dernier élément a un indice -1, l'avant-dernier élément a un indice -2, et ainsi de suite.
L'exemple suivant montre comment accéder aux éléments d'un array
📋 Copier le code
import numpy as np
a = np.arange(10, 15)
print(a)
print(a[0])
print(a[1])
print(a[-1])
Création de arrayx bidimensionnels
L'exemple suivant utilise la fonction array() pour créer un array bidimensionnel (2-D) :
📋 Copier le code
import numpy as np
b = np.array([[1, 2, 3],[4, 5, 6]])
print(b)
x=b.ndim
print(str(x) + " dimensions")
Dans cet exemple, nous passons une liste d'une liste d'entiers à la fonction array(). La propriété ndim renvoie 2 comme prévu.
Une bonne astuce pour obtenir le nombre de dimensions d'un array est de compter les crochets ([) jusqu'à ce que vous rencontriez le premier nombre. Le nombre de crochets correspond au nombre de dimensions ou d'axes.
Un array à deux dimensions est également appelé une matrice.
Indexation de l'array NumPy sur des arrays 2-D
Avec les arrays 2-D et multidimensionnels, vous pouvez sélectionner des éléments comme vous l'avez fait avec les arrays 1-D, mais pour chaque dimension (ou axe). Par exemple :
📋 Copier le code
import numpy as np
a = np.array([[1, 2, 3],[4, 5, 6]])
print(a[0]) # [1 2 3]
print(a[1]) # [4 5 6]
print(a[0, 0]) # 1
print(a[1, 0]) # 4
print(a[0, 2]) # 3
print(a[1, 2]) # 6
print(a[0, -1]) # 3
print(a[1, -1]) # 6
Création d'un array tridimensionnel
L'exemple suivant utilise la fonction array() pour créer un array tridimensionnel (3-D) :
📋 Copier le code
import numpy as np
c = np.array(
[
[
[1, 2, 3],
[4, 5, 6]
],
[
[7, 8, 9],
[10, 11, 12]
],
]
)
print(c)
x=c.ndim
print("Array à " + str(x) + " dimensions")
print("De type : " + str(c.dtype))
Indexation de l'array NumPy sur des arrays 3-D
L'exemple suivant crée un array NumPy 3-D :

Cette image montre que nous avons :
Deux index sur l'axe-0, donc on aura les indexs 0 et 1
Trois indexs sur l'axe-1, on aura alors les indexes 0, 1 et 2
ET en fin deux indexs sur l'axe-2, et on aura donc les indexs 0 et 1
pour avoir un élément on l'idexe comme suit :
[index axe-0, index axe-1, index axe-2]
📋 Copier le code
import numpy as np
a = np.array([
[[1, 2], [3, 4], [5, 6]],
[[5, 6], [7, 8], [9, 10]],
])
print(a[0, 0, 1]) # retourne 2
print(a[0, 2, 1]) # retourne 6
Découpage d'un array Numpy sur des arrays uni-dimensionnels D-1
Les arrays NumPy utilisent les [] et : pour le découpage en tranches comme les listes. En utilisant les tranches, vous pouvez sélectionner une plage d'éléments dans un array avec la syntaxe suivante :
[m:n]
Cette tranche sélectionne les éléments commençant par m et se terminant par n-1. Notez que le nième élément n'est pas inclus. En fait, la tranche m:n peut être définie explicitement comme suit :
[m:n:1]
Le chiffre 1 indique que la tranche sélectionne tous les éléments entre m et n , n non inclus.
Pour sélectionner tous les deux éléments, vous pouvez utiliser la tranche suivante :
[m:n:2]
En général, l'expression suivante sélectionne tous les k éléments entre m et n :
[m:n:k]
Si k est négatif, la tranche renvoie les éléments dans l'ordre inverse, de m à n+1. Le tableau suivant illustre les expressions de découpage en tranches :
Tranche Expression | > Signification |
a[m:n] | Sélectionner les éléments dont l'indice commence à m et se termine à n-1. |
a[:] or a[0:-1] | Sélectionner tous les éléments dans un axe donné |
a[:n] | Sélectionner les éléments à partir de l'indice 0 jusqu'à l'élément d'indice n-1. |
a[m:] | Sélectionne les éléments à partir de l'indice m jusqu'au dernier élément. |
a[m:-1] | Sélectionner les éléments à partir de l'indice m jusqu'au dernier élément. |
a[m:n:k] | Sélectionner les éléments d'indice m à n (exclusif), avec un incrément k |
a[::-1] | Sélectionne tous les éléments dans l'ordre inverse |
Voir l'exemple suivant:
[index axe-0, index axe-1, index axe-2]
📋 Copier le code
import numpy as np
a = np.arange(10, 101,10)
print('a=', a)
print('a[2:5]=', a[2:5])
print('a[:]=', a[:])
print('a[0:-1]=', a[0:-1])
print('a[0:6]=', a[0:6])
print('a[7:]=', a[7:])
print('a[5:-1]=', a[5:-1])
print('a[0:5:2]=', a[0:5:2])
print('a[::-1]=', a[::-1])
Découpage de tableaux Numpy sur des arrays multidimensionnels
Pour découper un array multidimensionnel, vous appliquez les crochets [] et la notation : à chaque dimension (ou axe). Le découpage renvoie un array réduit dont chaque élément correspond aux règles de sélection.
Par exemple :
📋 Copier le code
import numpy as np
a = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
print(a[0:2, :])
L'image qui suit montre les éléments que nous avons sélectionné par l'expression a[0:2, :] en vert

Dans cet exemple, le array a est un array 2-D.
Dans l'expression a[0:2, :]
D'abord, le 0:2 sélectionne les éléments à l'indice 0 et 1, c'est-à-dire les éléments du début jusqu'à l'élément avec l'index 2 non inclus ce qui renvoie :
[[1 2 3]
[4 5 6]]
Ensuite, le : sélectionne tous les éléments. Par conséquent, l'expression entière retourne :
[[1 2 3]
[4 5 6]]
Prenons un autre exemple :
📋 Copier le code
import numpy as np
a = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
print(a[1:, 1:])
Dans l'expression a[1 :, 1 :]:
D'abord, (1: ) sélectionne les éléments à partir de l'indice 1 jusqu'au dernier élément du premier axe (ou ligne), ce qui renvoie :
[[4 5 6]
[7 8 9]]
Second, 1 : sélectionne les éléments à partir de l'indice 1 jusqu'aux derniers éléments du second axe (ou colonne), ce qui donne :
[[5 6]
[8 9]]
Indexation fantaisiste
Dans le tutoriel précédent, vous avez appris à sélectionner les éléments d'un tableau NumPy en utilisant les techniques d'indexation et de découpage.
En plus de l'utilisation de l'indexation et du découpage, NumPy vous fournit un moyen pratique d'indexer un array appelé fancy indexing.
L'indexation fantaisiste vous permet d'indexer un array numpy en utilisant ce qui suit :
Un autre array NumPy
Une liste Python
Une séquence d'entiers
Voyons l'exemple suivant :
📋 Copier le code
import numpy as np
a = np.arange(1, 10)
print(a)
indices = np.array([2, 3, 4])
print(a[indices])
Sortie :
[1 2 3 4 5 6 7 8 9]
[3 4 5]
Comment cela fonctionne?
Tout d'abord, nous avons utilisé la fonction arange() pour créer un array numpy (a) avec les nombres de 1 à 9 :
a=[1 2 3 4 5 6 7 8 9]
Ensuite, créez un deuxième array numpy pour l'indexation :
indices = np.array([2, 3, 4])
Ce qui définie les indexes dont on veut obtenir éléments
Troisièmement, utilisez le tableau indices pour indexer le tableau a :
print(a[indices])
L'indexation fantaisiste vous permet d'indexer un tableau à l'aide d'un autre tableau, d'une liste ou d'une séquence d'entiers.
Indexation booléenne d'un array NumPy
Numpy vous permet d'utiliser un array de valeurs booléennes comme index d'un autre array. Chaque élément de l'array booléen indique s'il faut ou non sélectionner les éléments de l'array.
Si la valeur est True, l'élément de cet index est sélectionné. Dans le cas où la valeur est False, l'élément de cet index n'est pas sélectionné.
L'exemple suivant utilise l'indexation booléenne pour sélectionner les éléments d'un array numpy en utilisant un array de valeurs booléennes :
📋 Copier le code
import numpy as np
a = np.array([1, 2, 3])
b = np.array([True, True, False])
c = a[b]
print(c)
Généralement, vous utiliserez l'indexation booléenne pour filtrer un array. Par exemple :
📋 Copier le code
import numpy as np
a = np.arange(1, 10)
b = a > 6
print(b)
c = a[b]
print(c)
Sortie de ce code:
[False False False False False False True True True]
[7 8 9]
Comment cela fonctionne?
D'abord, créez un array qui contient 9 nombres de 1 à 9 en utilisant la fonction arange() :
a = np.arange(1, 10)
Ensuite, créez un array booléen à partir de l'expression suivante :
b = a > 6
Cette expression compare chaque élément du array a avec 6 et renvoie Vrai s'il est supérieur à 6 ou Faux sinon.
La variable b est un array de valeurs booléennes :
[False False False False False False True True True]
Troisièmement, utilisez le array b comme index du array a et assignez le résultat à la variable c :
c = a[b]
Le array c contient uniquement les nombres du array a, qui sont supérieurs à 6.