Institut Supérieur d’Informatique et de

Multimédia de Gabès (ISIMG)

Chapitre 7 : Les tableaux en Python

Année universitaire : 2023-2024

Plan

I. Introduction
II. La bibliothèque NumPy
III. Création des tableaux
IV. Manipulation des tableaux
V. Calcul vectoriel et matriciel
VI. Tri des tableaux

1
 I. Introduction

En algorithmique, les tableaux sont des structures de données qui

permettent de stocker un certain nombre d’éléments. Le nombre
d’éléments d’un tableau est fixe. Chaque élément est repéré par un index
qui est un entier.
Les éléments d’un tableau ont tous le même type. Il s’agit d’une structure
de données homogène.
Un tableau peut être aussi appelé table, vecteur (cas d’un tableau
unidimensionnel), ou matrice (cas d’un tableau bidirectionnel).
En Python, les tableaux présentent une structure de données proposée
par la bibliothèque NumPy. Ils sont utilisés pour effectuer les calculs
mathématiques sur les vecteurs et les tableaux multidimensionnels.
Les tableaux NumPy ressemblent aux listes. Mais, ils sont plus rapides à
être traités et utilisent moins de mémoire comparés aux listes. En plus, on
peut réaliser des opérations sur les tableaux sans utiliser les boucles.

II. La bibliothèque NumPy

NumPy est une bibliothèque dédiée au calcul scientifique, qui

permet de manipuler les tableaux, notamment les tableaux larges
multidimensionnels, et d’effectuer des opérations mathématiques
de haut niveau telles que l’analyse des données, l’algèbre linéaire et
les statistiques.
NumPy est une bibliothèque externe à Python. Donc, elle doit être
téléchargée et installée.
Après installation, NumPy doit être importée avant d’être utiliser.
L’importation s’effectue souvent comme suit : import numpy as np.
Dans ce chapitre, l’appel des fonctions de NumPy s’effectue avec la
syntaxe np.nom_fonction(…).
Dans NumPy, les tableaux sont représentés par le type ndarray.

2
 II. La bibliothèque NumPy

Les éléments d’un tableau Numpy doivent être de même type.

Les tableaux Numpy sont mutables (on peut modifier les valeurs des
éléments d’un tableau). Mais, la taille d’un tableau est fixe : Les
fonctions d’insertion et de suppression ne modifient pas le tableau
d’origine, mais elles retournent un nouveau tableau en ajoutant ou
supprimant des éléments du tableau initial.

III. Création des tableaux

III.1. Création des tableaux unidimensionnels (vecteurs) :

Il existe deux fonctions qui sont utilisées pour créer des tableaux :
La fonction np.array(L) : Cette fonction permet de convertir une liste ou un tuple,
qui est passé comme argument, en un tableau de type ndarray. On peut changer
le type d’éléments en précisant le type avec ou sans l’option dtype.
La fonction np.ndarray(n) : Cette fonction permet de créer un tableau aléatoire
de réels (type float) de longueur n passée en argument. On peut choisir le type
d’éléments du tableau en indiquant le type avec ou sans l’option dtype.
Exemple : Les fonctions np.ndarray(n, dtype=int) et np.ndarray(n, int) permettent de
créer un vecteur de n entiers aléatoires.

3
 III. Création des tableaux

Exemples

>>>T=np.array([4,2,-7,12,20]) #conversion d’une liste en un tableau

>>> T
array([ 4, 2, -7, 12, 20])
>>>T0=np.array((4,2,-7,12,20)) #conversion d’une tuple en un tableau
>>> T0
array([ 4, 2, -7, 12, 20])
>>> T1=np.ndarray(3) #génération aléatoire d’un tableau de 3 réels
>>> T1
array([2.14321575e-312, 2.29175545e-312, 5.48412867e-322])
>>> T2=np.ndarray(4,dtype=int) #génération aléatoire d’un tableau de 4 entiers
>>> T2
array([1044874894, -549167882, 790328138, 1426366762])

III. Création des tableaux

III.2. Création des tableaux bidimensionnels (matrices)

Les fonctions utilisées pour créer des vecteurs sont également
utilisées pour créer des matrices :
La fonction np.array(L) : Cette fonction permet de convertir une liste ou un
tuple, qui est passé comme argument, en un tableau de type ndarray. On
peut changer le type d’éléments en précisant le type avec ou sans l’option
dtype. Les éléments de la liste (ou du tuple) sont des listes (ou des tuples)
dont chacune présente une ligne de la matrice.
La fonction np.ndarray((n,m)) : Cette fonction permet de créer une matrice
de réels de taille n*m (n lignes et m colonnes). On peut choisir le type
d’éléments du tableau en indiquant le type avec ou sans l’option dtype.

4
 III. Création des tableaux

Exemples

>>> M=np.ndarray((2,3)) #génération aléatoire d’une matrice d’entiers de taille 2*3

>>> M
array([[3.44900878e-307, 4.22786102e-307, 2.78145267e-307],
[4.00537061e-307, 9.45656391e-308, 4.28269564e+202]])
>>>L=[[1,2,3],[4,8,9]] #liste d’entiers qui contient 2 listes comme éléments
>>>M1=np.array(L) #conversion de la liste L en une matrice de taille 2*3
>>>M1
array([[1, 2, 3],
[4, 8, 9]])
>>>T=([0,-2,8],[1,4,3],[-2,3,4]) #tuple d’entiers qui contient 3 tuples comme éléments
>>> M2=np.array(T, float)
>>> M2 #matrice de 3 lignes et de 3 colonnes
array([[ 0., -2., 8.],
[ 1., 4., 3.],
[-2., 3., 4.]])

III. Création des tableaux

III.3. Création des tableaux particuliers

Il existe plusieurs fonctions pour créer des tableaux particuliers :
La fonction np.arange() : Création d’un vecteur dont les éléments sont
régulièrement espacés.
La fonction np.linspace() : Création d’un vecteur dont les éléments sont
linéairement espacés. Le nombre d’éléments du tableau est indiqué dans les
paramètres de la fonction (par défaut, il est égal à 50).
La fonction np.logspace() : Création d’un vecteur dont les éléments sont
logarithmiquement espacés. Le nombre d’éléments du tableau est indiqué
dans les paramètres de la fonction.

10

5
 III. Création des tableaux

La fonction np.zeros() : Création d’un vecteur ou d’une matrice dont tous les
éléments sont des zéros et dont la taille est indiquée dans les paramètres de
la fonction.
La fonction np.ones() : Création d’un vecteur ou d’une matrice dont tous les
éléments sont des 1 et dont la taille est indiquée dans les paramètres de la
fonction.
La fonction np.diag() : Création d’une matrice diagonale dont les coefficients
diagonaux sont les éléments d’une liste, d’un vecteur ou d’un tuple passé en
paramètre.
La fonction np.eye() : Création d’une matrice identité.

11

III. Création des tableaux

Exemples de création des tableaux particuliers (1/4)

fonction Rôle Exemple

np.arange(N) Création d’un tableau d’entiers >>>T=np.arange(5)

ou de réels (pas=1), dans >>>T
l’intervalle [0,N[, avec N>0. array([0,1,2,3,4])
On peut changer le type >>>T1=np.arange(5, dtype=float)
d’éléments en utilisant l’option >>>T1
dtype=type. >>>array([0., 1., 2., 3., 4.])
>>>T2=np.arange(3.5)
>>>T2
array([0., 1., 2., 3.])
np.arange(N,M) Création d’un tableau d’entiers >>>T=np.arange(5,10)
ou de réels, dans l’intervalle >>>T
[N,M[ (pas=1). array([5, 6, 7, 8, 9])
>>>T1=np.arange(-2.2,2)
>>>T1
array([-2.2, -1.2, -0.2, 0.8, 1.8])
np.arange(N,M,p) Création d’un tableau d’entiers >>>T=np.arange(5,25,5)
ou de réels, dans l’intervalle >>>T
[N,M[ avec un pas p. array([ 5, 10, 15, 20])
>>> T1=np.arange(0.5,2,0.25)
>>> T1
array([0.5 , 0.75, 1. , 1.25, 1.5 , 1.75])
12

6
 III. Création des tableaux

Exemples de création des tableaux particuliers (2/4)

fonction Rôle Exemple

np.linspace(N,M,P) Création d’un tableau de P >>> T=np.linspace(-2,2,5)
éléments allant de N >>> T
jusqu’au M, avec M inclus. array([-2., -1., 0., 1., 2.])

np.linspace(N,M,P, Création d’un tableau de P >>>T=np.linspace(-2,2,5,endpoint=False)

endpoint=False) éléments allant de N jusqu’à >>> T
M, avec M non inclus. array([-2. , -1.2, -0.4, 0.4, 1.2])
Par défaut endpoint=True.
np.logspace(N,M,P) Création d’un tableau de P >>> T=np.logspace(-2,2,5)
éléments qui sont compris >>> T
entre 10N et 10M , avec 10M array([1.e-02, 1.e-01, 1.e+00, 1.e+01,
inclus. 1.e+02])

np.logspace(N,M,P, Création d’un tableau de P >>> T=np.logspace(-2,2,5,endpoint=False)

endpoint=False) éléments qui sont compris >>> T
entre 10N et 10M , avec 10M array([1.00000000e-02, 6.30957344e-02,
non inclus. 3.98107171e-01, 2.51188643e+00,
Par défaut endpoint=True. 1.58489319e+01])
13

III. Création des tableaux

Exemples de création des tableaux particuliers (3/4)

fonction Rôle Exemple

np.logspace(N,M,P, Création d’un tableau de P >>> T=np.logspace(-2,2,5,base=2)

base=nbre) éléments qui sont compris >>> T
entre nbreN et nbreM , avec array([0.25, 0.5 , 1. , 2. , 4. ])
nbreM inclus. nbre désigne la >>> T=np.logspace(-2,2,5, base=5)
base logarithmique à utiliser. >>> T
10 est la base par défaut. array([ 0.04, 0.2 , 1. , 5. , 25. ])

np.zeros(n) Création d’un tableau de n >>>T=np.zeros(2)

zéros. >>> T
array([0., 0.])
np.zeros((n,m)) Création d’une matrice de >>> M=np.zeros((2,3))
n*m zéros. >>> M
array([[0., 0., 0.],
[0., 0., 0.]])
np.ones(n) Création d’un tableau de n >>> T=np.ones(3)
éléments égaux à 1. >>> T
array([1., 1., 1.])
np.ones((n,m)) Création d’une matrice de >>> T=np.ones((2,3))
n*m éléments égaux à 1. >>> T
array([[1., 1., 1.],
[1., 1., 1.]]) 14

7
 III. Création des tableaux

Exemples de création des tableaux particuliers (4/4)

fonction Rôle Exemple
np.diag(L) Création d’une >>> L=[1,5,7]
matrice carrée de >>>M=np.diag(L)
taille len(L), avec L >>>M
peut être un vecteur, array([[1, 0, 0],
une liste ou un tuple. [0, 5, 0],
[0, 0, 7]])
np.eye(n) Création d’une >>>M=np.eye(4)
matrice identité de >>>M
taille n*n. array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
np.eye(n,m) Création d’une >>> M=np.eye(3,4)
matrice identité de >>> M
taille n*m. array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.]]) 15

IV. Manipulation des tableaux

IV.1. Taille d’un tableau

Il existe certaines fonctions qui renvoient la taille d’un tableau :
La fonction np.shape(T) : Elle retourne un tuple qui contient le nombre
d’éléments d’un tableau (cas d’un vecteur) ou le nombre de lignes et de
colonnes (cas d’une matrice).
La fonction np.alen(T) : Elle donne la première dimension d’un tableau (la
taille d’un vecteur ou le nombre de lignes d’une matrice).
La fonction np.size(T) : Elle retourne le nombre d’éléments d’un tableau.
Exemples >>>T=np.array([1,2,3,4])
>>> M=np.array([[1,2,3],[4,5,6]])
>>>np.size(T)
4
>>> np.size(M)
6
>>> np.shape(T)
(4,)
>>> np.shape(M)
(2, 3)
>>> np.alen(T)
4
>>> np.alen(M)
16
2

8
 IV. Manipulation des tableaux

IV.2. Accès aux éléments d’un tableau

Similairement aux listes, on peut accéder à un élément d’un tableau
par son indice et on peut extraire un ensemble d’éléments (slicing).
L’extraction peut être aussi effectuée par une liste d’indices.
Indexation : Elle est effectuée avec les entiers positifs ou négatifs. Pour les
matrices, l’accès est effectué en utilisant deux indices, le premier pour
indiquer le numéro de la ligne et le deuxième pour indiquer le numéro de la
colonne.
Exemples
>>>T=np.array([1,2,3,4])
>>> T
array([1, 2, 3, 4])
>>> T[0] #accès au premier un élément du vecteur
1
>>> T[-2] #accès au troisième élément du vecteur
3
>>> M=np.array([[1,2,3,4],[7,8,9,10]])
>>> M
array([[ 1, 2, 3, 4],
[ 7, 8, 9, 10]])
>>> M[0][3] #accès à l’élément de la première ligne et de la quatrième colonne
17
4

IV. Manipulation des tableaux

Le découpage et l’extraction de sous tableaux (slicing) : Le slicing permet

d’accéder à plusieurs éléments d’un tableau sur une ou plusieurs dimensions.
Pour le cas d’un tableau bidimensionnel (matrice), on peut extraire une ou
plusieurs lignes (et/ ou colonnes) ou bien des éléments de certaines lignes ou
colonnes. Le tableau suivant contient des exemples des slices.

Slice Résultat
T[i:j] Sous tableau de T à partir de T[i] jusqu’à T[j-1]
T[:i] Sous tableau de T à partir de T[0] jusqu’à T[i-1].
T[i:] Sous tableau de T à partir de T[i] jusqu’à T[len(T)-1].
T[i:j:k] Sous tableau de T à partir de T[i] jusqu’à T[j-1] avec le pas k.
T[::i] Sous tableau à partir de T[0] jusqu’à la fin du tableau T avec le pas i.
T[::-i] Même résultat du slice précédent mais à l’envers.

18

9
 IV. Manipulation des tableaux
Exemples de slicing
>>>T=np.arange(10)
>>> T
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> T[2:] #extraction des éléments à partir de T[2] jusqu’à T[9]
array([2, 3, 4, 5, 6, 7, 8, 9])
>>> T[:3] #extraction des 3 premiers éléments de T
array([0, 1, 2])
>>> T[::-1] #inversion de T
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
>>>M=np.array([[1, 2, 3],[4, 5, 6],[7,8,9]])
>>> M
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> M[2,:] #extraction de la troisième ligne de M
array([7, 8, 9])
>>>M[:,1] # extraction de la deuxième colonne de M
array([2, 5, 8])
>>> M[:2,:] # extraction des deux premières lignes de M
array([[1, 2, 3],
[4, 5, 6]])
>>> M[1:,:2] # extraction des deux premiers éléments de la 2ème et 3ème lignes de M
array([[4, 5],
19
[7, 8]])

IV. Manipulation des tableaux

Liste d’indices : Le slicing permet d’extraire des éléments qui ont des indices
successifs dans une dimension ou qui sont espacés d’une même distance si
un pas d’incrémentation est spécifié. On peut effectuer une extraction
d’éléments quelconques en utilisant une liste d’indices pour chaque
dimension (c’est-à-dire spécifier une liste d’indices pour les lignes et/ou une
autre pour les colonnes d’éléments à extraire dans le cas d’une matrice).
Exemples
>>>T=np.array([21,2,8,9,4,17,3])
>>>a=[0,4,5,1] #liste des indices
>>> T[a]
array([21, 4, 17, 2])
>>>M=np.array([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]])
>>> l=[3,2]
>>> c=[0,2]
>>> M[l]
array([[10, 11, 12],
[ 7, 8, 9]])
>>> M[c]
array([[1, 2, 3],
[7, 8, 9]])
>>> M[l,c]
array([10, 9]) 20

10
 IV. Manipulation des tableaux

IV.3. Copie d’un tableau

On peut créer une copie d’un tableau en utilisant les fonctions np.copy(T) ou
T.copy(). Ces deux fonctions permettent de créer une copie indépendante du
tableau initial Toute modification apportée à la copie (ou au tableau
original) n’a aucun effet sur le tableau original (ou à la copie).
L’instruction T1=T ne permet pas de créer une nouvelle copie du tableau T,
mais elle demande à la variable T1 de pointer sur l’emplacement de T dans la
mémoire Toute modification apportée à T1 (ou T) mène à une
modification de T (ou T1).
Exemples
>>>T=np.array([4,6,7,8]) >>>T=np.array([7,8,10,11]) >>>T=np.array([7,8,10,11])
>>> T1=T >>> T2=T.copy() >>>T3=np.copy(T)
>>>T1[0]=5 >>>T2[0]=6 >>> T3[1]=5
>>> T1 >>> T2 >>> T3
array([5, 6, 7, 8]) array([ 6, 8, 10, 11]) array([ 7, 5, 10, 11])
>>> T # T modifié >>> T # T non modifié >>> T # T non modifié
array([5, 6, 7, 8]) array([7,8,10,11]) array([7,8,10,11])

21

IV. Manipulation des tableaux

IV.4. Concaténation des tableaux

On peut concaténer des tableaux en utilisant plusieurs fonctions
parmi lesquelles :
La fonction np.concatenate() : Elle permet de concaténer plusieurs tableaux
sur un axe donné. Si l’axe n’est pas spécifié, les matrices sont concaténées
verticalement et les vecteurs sont concaténer horizontalement.
La fonction np.hstack() : Elle permet de concaténer des tableaux
horizontalement.
La fonction np.vstack() : Elle permet de concaténer des tableaux
verticalement.

22

11
 IV. Manipulation des tableaux

Exemples de concaténation des tableaux

fonction Rôle Exemple

np.concatenate((T,T1,…)) Concaténation des >>> T=np.array([1,2])

tableaux, donnés sous >>> T1=np.array([3,4,5])
forme d’un tuple. >>> T2=np.array([6,7,8,9])
>>> np.concatenate((T,T1,T2))
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
np.concatenate((T,T1,…) ,axis=…) Concaténation des >>> M=np.array([[1,2,3],[4,5,6]])
matrices, donnés sous >>> M1=np.array([[7,8],[9,10]])
forme d’un tuple, >>> np.concatenate((M,M1),axis=1)
horizontalement (axis=1) array([[ 1, 2, 3, 7, 8],
ou verticalement (axis=0). [ 4, 5, 6, 9, 10]])
np.hstack((T,T1,…)) Concaténation >>> M1=np.array([[5,6],[7,8]])
horizontale des tableaux, >>> M=np.array([[1,2],[3,4]])
donnés sous forme d’un >>> np.hstack((M,M1))
tuple. array([[1, 2, 5, 6],
[3, 4, 7, 8]])
np.Vstack((T,T1,…)) Concaténation verticale >>> T=np.array([1,2,3])
des tableaux, donnés >>> T1=np.array([4,5,6])
sous forme d’un tuple. >>> np.vstack((T,T1))
array([[1, 2, 3],
[4, 5, 6]])
23

IV. Manipulation des tableaux

IV.5. Conversion d’un tableau

Un tableau peut être converti en une liste, en une matrice (cas d’un
vecteur) ou en un vecteur (cas d’une matrice).
Type de conversion Exemple

Conversion d’un tableau en une liste en >>> T=np.arange(5)

utilisant la fonction tolist(). >>> L=T.tolist(); L
[0, 1, 2, 3, 4]
Conversion d’un vecteur en une matrice en >>> T=np.array([3,4,5,8,10,12])
utilisant la fonction np.reshape(T,(m,n)), m et >>> M=np.reshape(T,(2,3))
n sont les dimensions de la matrice de >>> M
conversion. array([[ 3, 4, 5],
[ 8, 10, 12]])
Conversion d’une matrice en un vecteur en >>> M=np.array([[1, 2, 3],[4, 5, 6]])
utilisant la fonction np.reshape(M,n), avec n le >>> T=np.reshape(M,6); T
nombre d’éléments de la matrice. array([1, 2, 3, 4, 5, 6])
Conversion d’une matrice en un vecteur en >>> M=np.array([[1, 2, 3],[4, 5, 6]])
utilisant la fonction flatten(). >>> T=M.flatten()
>>> T
24
array([1, 2, 3, 4, 5, 6])

12
 IV. Manipulation des tableaux

IV.6. Modification des éléments d’un tableau

On peut changer à la fois les valeurs de plusieurs éléments des
tableaux en utilisant les slices. >>> M[:,1]=-1
>>>T=np.arange(10) >>> M
>>> T array([[ 1, -1, 3],
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) [ 4, -1, 6],
>>> T[1:4]=5 #changement des valeurs des éléments [ 7, -1, 9],
d’indices 1, 2 et 3 par la valeur 5 [10, -1, 12]])
>>> T >>> M[2:]=-2
array([0, 5, 5, 5, 4, 5, 6, 7, 8, 9]) >>> M
>>> T[6:]=(-1,-2,-3,-4) #changement des valeurs de T[6], array([[ 1, -1, 3],
T[7], T[8] et T[9] par les valeurs respectives -1, -2, -3, -4 [ 4, -1, 6],
>>> T [-2, -2, -2],
array([ 0, 5, 5, 5, 4, 5, -1, -2, -3, -4]) [-2, -2, -2]])
>>>M=np.array([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]]) >>> M[:2,::2]=-5
>>>M >>> M
array([[ 1, 2, 3], array([[-5, -1, -5],
[ 4, 5, 6], [-5, -1, -5],
[ 7, 8, 9], [-2, -2, -2],
[10, 11, 12]]) [-2, -2, -2]])
25

IV. Manipulation des tableaux

IV.7. Ajout des éléments (1/2)

On peut ajouter des éléments à un tableau en utilisant deux
fonctions:
np.insert() : Ajout d’un ou de plusieurs éléments dans une position bien
déterminée.
np.append() : Ajout d’un ou de plusieurs éléments à la fin d’un tableau.

26

13
 IV. Manipulation des tableaux

Exemples d’insertion des éléments dans un tableau (1/2)

fonction Rôle Exemple
np.insert(T,i,x) Insertion de x dans la >>>T=np.arange(4)
position i du tableau T >>> T=np.insert(T,1,7)
(dans ce cas T est un >>>T
vecteur), x peut être array([0, 7, 1, 2, 3])
une seule valeur, un >>> T=np.insert(T,3,[-1,-2,-4]) ; T
tuple ou une liste. array([ 0, 7, 1, -1, -2, -4, 2, 3])
np.insert(M,i,L, axis=…) Dans ce cas, M est une >>> M=np.array([[1,2,3],[4,5,6]])
matrice et L est une >>> M=np.insert(M,1,[-1,-2,-3],axis=0)
liste. axis=0, si on veut >>>M
ajouter L comme une array([[ 1, 2, 3],
ligne dans M dans la [-1, -2, -3],
position i. [ 4, 5, 6]])
axis=1, si on veut >>> M=np.insert(M,2,[7,8,9],axis=1)
insérer L comme une >>> M
colonne dans M. array([[ 1, 2, 7, 3],
[-1, -2, 8, -3],
[ 4, 5, 9, 6]])

27

IV. Manipulation des tableaux

Exemples d’insertion des éléments dans un tableau (2/2)

fonction Rôle Exemple

np.append(T,x) Insertion de x à la fin du >>>T=np.arange(4)
tableau T (dans ce cas T >>> T=np.append(T,-5)
est un vecteur), x peut >>> T
être une seule valeur (ou array([ 0, 1, 2, 3, -5])
variable), un tuple ou une >>> T=np.append(T,[10,13,14])
liste. >>> T
array([ 0, 1, 2, 3, -5, 10, 13, 14])
np.append(M,L, axis=…) Dans ce cas, M est une >>> M=np.array([[1,2,3],[4,5,6]])
matrice et L est une liste >>> M=np.append(M,[[7,8,9]],axis=0)
ou un tuple. axis=0 si on >>> M
veut ajouter L comme array([[1, 2, 3],
une ligne à la fin de M. [4, 5, 6],
axis=1, si on veut insérer [7, 8, 9]])
L comme une colonne à la >>> M=np.append(M, [[-1],[-2],[0]],axis=1)
fin de M. >>> M
array([[ 1, 2, 3, -1],
[ 4, 5, 6, -2],
[ 7, 8, 9, 0]])

28

14
 IV. Manipulation des tableaux

IV.8. Suppression des éléments

On peut supprimer des éléments d’un tableau en utilisant la
fonction np.delete(…).
fonction Rôle Exemple
np.delete(T,i) Suppression de l’élément T[i] >>>T=np.arange(4)
du tableau T, avec T un >>> T
vecteur. array([0, 1, 2, 3])
>>> T=np.delete(T,2)
>>> T
array([0, 1, 3])
np.delete(M,i, axis=…) Suppression de la ligne >>> M=np.array([[1,2,3],[4,5,6],[7,8,9]])
d’indice i de M (si axis=0) et >>> M
de la colonne d’indice i (si array([[1, 2, 3],
axis=1), avec M une matrice [4, 5, 6],
[7, 8, 9]])
>>> M=np.delete(M,1,axis=0)
>>> M
array([[1, 2, 3],
[7, 8, 9]])
>>> M=np.delete(M,2,axis=1)
>>> M
array([[1, 2],
[7, 8]]) 29

IV. Manipulation des tableaux

IV.9. Recherche dans les tableaux

On peut chercher les éléments d’un tableau qui vérifient une
certaine propriété en utilisant essentiellement les fonctions
suivantes :
La fonction np.where(condition) : Elle retourne le tableau des positions des
éléments d’un vecteur qui vérifient une propriété recherchée. Pour le cas
d’une matrice, cette fonction renvoie deux tableaux qui contiennent
respectivement les numéros de lignes et de colonnes qui vérifient la
propriété recherchée.
La fonction np.extract(condition,T) : Elle retourne un tableau qui contient les
éléments qui vérifient la condition recherchée.

30

15
 IV. Manipulation des tableaux

Exemples

>>>T=np.array([21,2,8,9,4,17,3])
>>>np.where(T>=9) #recherche des indices des éléments de T qui sont >=9
(array([0, 3, 5], dtype=int32),)
>>> M=np.array([[-1,2,3],[4,-5,6],[7,-8,9]])
>>> np.where(M<2) #recherche des indices des éléments de M qui sont <2
(array([0, 1, 2], dtype=int32), array([0, 1, 1], dtype=int32))
>>> np.extract(T>=9,T) #recherche des éléments de T qui sont >=9
array([21, 9, 17])
>>> np.extract(M<2,M) #recherche des éléments de M qui sont <2
array([-1, -5, -8])

31

V. Calcul vectoriel et matriciel

Les opérations mathématiques de base (addition, soustraction,

multiplication et division) sont applicables sur les tableaux.
On peut ajouter, soustraire, diviser ou multiplier tous les éléments
d’un vecteur ou d’une matrice par une même valeur.
Ces opérations sont effectuées terme à terme. Pour cette raison, il
faut que :
les tableaux aient la même taille (cas de deux vecteurs ou de deux matrices).
le nombre de colonnes soit égal à la taille du vecteur (cas d’un vecteur et
d’une matrice).

32

16
 V. Calcul vectoriel et matriciel

Exemples
>>> T=np.arange(6); >>> T2=np.array([1,2,-3])
>>>T1=np.arange(7,13) >>> M*T2
>>> T array([[ 1, 4, -9],
array([0, 1, 2, 3, 4, 5]) [ 4, 10, -18]]
>>> T1 >>> M*T
array([ 7, 8, 9, 10, 11,12]) Traceback (most recent call last):
>>> T+5 File "<pyshell#270>", line 1, in <module>
array([ 5, 6, 7, 8, 9, 10]) M*T
>>>T+T1 ValueError: operands could not be broadcast
array([ 7, 9, 11, 13, 15, 17]) together with shapes (2,3) (6,)
>>> M=np.array([[1,2,3],[4,5,6]]) M2=np.array([[1,0],[2,3],[-1,-2],[3,1]])
>>> M*3 >>> np.shape(M)
array([[ 3, 6, 9], (2, 3)
[12, 15, 18]]) >>> np.shape(M2)
>>> M1=np.array([[0,1,2],[-1,-2,0]]) (4, 2)
>>> M*M1 >>>M2*M
array([[ 0, 2, 6], Traceback (most recent call last):
[ -4, -10, 0]]) File "<pyshell#279>", line 1, in <module>
M2*M
ValueError: operands could not be broadcast
together with shapes (4,2) (2,3)
33

V. Calcul vectoriel et matriciel

En plus des opérations élémentaires, NumPy offre une multitude de

fonctions qui renvoient des résultats fréquemment utilisés tels que
les valeurs min et max d’un tableau.
Exemples
fonction Rôle Exemple

np.min(T) Recherche du plus petit élément du tableau T. >>> T=np.arange(1,6) ; T

array([1, 2, 3, 4, 5])
>>> np.min(T)
1
np.max(T) Recherche du plus grand élément du tableau T. >>>T=np.arange(1,6) ; np.max(T)
5
np.sum(T) Calcul de la somme des éléments du tableau T. >>>T=np.arange(1,6) ; np.sum(T)
15
np.prod(T) Calcul du produit des éléments du tableau T. >>>T=np.arange(1,6) ; np.prod(T)
120
np.mean(T) Calcul de la moyenne des éléments du tableau T. >>>T=np.arange(1,6) ; np.mean(T)
3.0
np.sort(T) Tri du tableau T dans le sens croissant. >>> T1=np.array([7,8,1,-4,17,-2])
>>> np.sort(T1)
array([-4, -2, 1, 7, 8, 17]) 34

17
 V. Calcul vectoriel et matriciel

NumPy offre également plusieurs fonctions permettant d’effectuer

des calculs mathématiques compliqués tels que les calculs liés à
l’algèbre linéaire (produit matriciel, vecteurs propres,
diagonalisation, décomposition des matrices...).
Exemples
fonction Rôle Exemple
np.dot(A,B) Calcul du produit >>> M1=np.array([[1,0],[2,3],[-1,0]])
matriciel des matrices A >>> M=np.array([[1,2,3,0],[1,0,1,0]])
et B >>> np.dot(M1,M)
array([[ 1, 2, 3, 0],
[ 5, 4, 9, 0],
[-1, -2, -3, 0]])
np.transpose(A) Calcul de la transposée >>> M=np.array([[1, 2, 3],[4, 5, 6]])
de la matrice A >>> np.transpose(M)
array([[1, 4],
[2, 5],
[3, 6]])

35

V. Calcul vectoriel et matriciel

Exemples (suite)
fonction Rôle Exemple
np.trace(A) Calcul de la trace de la >>>M=np.array([[1,0],[2,3]])
matrice A. >>>np.trace(M)
4
np.linalg.det (A) Calcul du déterminant de la >>> M=np.array([[1,2,3],[1,0,2],[3,1,0]])
matrice A , avec A une >>> np.linalg.det(M)
matrice carrée. 13.0

np.linalg.eigvals(A) Calcul des valeurs propres >>> M=np.array([[2,3],[1,0]])

de la matrice A, avec A une >>> np.linalg.eigvals(M)
matrice carrée (le résultat array([ 3., -1.])
est un vecteur).
np.linalg.inv(A) Calcul de l’inverse de la >>> M=np.array([[2,3],[1,0]])
matrice A, avec A une >>> np.linalg.inv(M)
matrice carrée. array([[ 0. , 1. ],
[ 0.33333333, -0.66666667]])
np.linalg.eig(A) Calcul des valeurs et des >>> M=np.array([[2,3],[1,0]])
vecteurs propres de la >>> np.linalg.eig(M)
matrice A, avec A une (array([ 3., -1.]), array([[ 0.9486833 , -0.70710678],
matrice carrée. [ 0.31622777, 0.70710678]]))

36

18