Lycée Janson de Sailly Année 2021-2022

ECS1

TP 5
Tableaux et matrices

1. A quoi ça sert ?

Nous venons de voir en cours ce qu’est une matrice. Sous Python, il est assez courant et facile de
travailler avec des tableaux ou des matrices. Il peut s’agir de matrices de variables de tout type.

L’objectif de ce TP est de vous faire découvrir comment manipuler les matrices sous Python. Je
vous conseille de vous faire une fiche de tout ce que vous avez appris au cours de ce TP pour être
capable de réutiliser les commandes facilement.

2. Comment créer et modifier une matrice sous Python ?

Le programme d’ECG préconise d’utiliser la librairie numpy pour travailler avec des tableaux.
On les créera alors avec la commande np.array. Tapez les commandes suivantes pour comprendre
comment créer une matrice sous Python :

import numpy as np
A=np.array([1, 2, 3])
B=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
C=np.array([[1], [2], [3]])
print(’A=’, A, ’B=’, B, ’C=’,C)
print(type(A))

On retiendra donc, que pour créer une matrice, il faudra utiliser la syntaxe
np.array([[L1], [L2], ..., [Ln]]) où les différentes éléments de chaque ligne Li seront séparés
par des virgules.
On notera également que ces tableaux ou matrices forment un nouveau type de variables (dernière
ligne du programme précédent).

Exercice 1. Créer les matrices suivantes sous Python.

 
1 2 3  
1 3 5
A = 4 5 6 B=
2 1 8
7 8 9

3. Matrices particulières

Lorsque l’on travaille avec des matrices de taille élevée, il peut être bien pénible de rentrer tous
les coefficients à la main. Dans certains cas particuliers, on peut définir les matrices plus rapidement.
Voici la listes des matrices usuelles au programme :

ˆ L’instruction A = np.zeros([2,3]) affecte à A la matrice nulle de taille (2, 3).

1
 ˆ L’instruction A = np.ones([2,3]) affecte à A la matrice de taille (2, 3) dont tous les coeffi-
cients sont des 1.
ˆ L’instruction A= np.eye(2,3) affecte à A la matrice suivante :
 
1 0 0
0 1 0

et donc, en particulier, np.eyes(3,3) représente la matrice I4 .

Attention : pas de crochets ici, c’est une exception !
ˆ L’instruction A = np.linspace(a,b,n) permet d’obtenir un tableau d’un ligne allant d’une
valeur de départ a à une valeur d’arrivée b avec un nombre donné d’éléments n. Par exemple
A=np.linspace(2,3,5) donne :


2 2, 25 2, 5 2, 75 3
On l’utilisera souvent cette commande, plus tard, pour des représentations graphiques de fonc-
tions.
ˆ On peut aussi utiliser l’instruction np.arange qui permet de préciser le pas plutôt que le
nombre d’éléments du tableau. Par exemple, l’instruction A = np.arange(2,3,.25) affecte à
A la matrice

2 2, 25 2, 5 2, 75

On remarque ici que le tableau s’arrête juste avant le nombre donné pour l’arrivée.
Le pas par défaut est 1, ainsi, l’instruction A = np.arange(5,10) affecte à A la matrice


5 6 7 8 9 .

Enfin, la valeur initiale par défaut est 0, donc l’instruction A= np.arange(5) affecte à A la
matrice


0 1 2 3 4 .

Exercice 2. Créer le tableau des entiers pairs entre 0 et 100 rangés par ordre croissant , puis celui
des mêmes entiers par ordre décroissant ([100; 98; 96; . . . ; 0]).

4. Opérations sur les matrices

Accéder à des éléments d’une matrice

Lorsqu’on manipule des matrices, il est intéressant de pouvoir accéder à une ligne, un coefficient,
... pour les isoler ou même pour les changer. Sous Python, lorsqu’un tableau possède n lignes
et p colonnes, elles sont numérotées de 0 à n − 1 et de 0 à p − 1. On accède :
ˆ à l’élément situé à la ième ligne et la jème colonne via l’instruction A[i,j],
ˆ à la ième ligne via l’instruction A[i] qui renvoie donc un tableau contenant une ligne et p
colonnes,
ˆ à la jème colonne via l’instruction A[ :,j] qui renvoie un tableau contenant une ligne et n colonnes
(et non pas un vecteur colonne).

Exercice 3. Que renvoie la fonction suivante ?

2
import numpy as np
def diag(n):
A = np.zeros((n,n))
for i in range(n):
A[i,i] = i
return A

Exercice 4. Entrer une matrice C de taille (3, 4) de votre choix. Remplacer la deuxième ligne de la
matrice C par une ligne de 1, puis remplacer la deuxième colonne de la matrice C par la première
colonne de la matrice C.

Exercice 5. - Attention ! Cet exercice présente une étrangeté de Python.

Que se passe-t-il à l’exécution du programme suivant ?

a = [[3,1],[1,11]]
b = a[0]
b[0] = 2
print(a)

En fait la deuxième instruction ne crée pas une variable b mais une vue sur la première ligne de a.
Une modification de b agit donc aussi sur a. Cela peut être une source d’erreurs, pas toujours évidentes
à détecter... Pour contourner cette difficulté on utilisera une copie via la méthode copy :

a = [[3,1],[1,11]]
b = a[0].copy()
b[0] = 2
print(a)

Opérations élémentaires sur les matrices

Il faut faire attention à bien distinguer deux types d’opérations mathématiquement différentes dans
les matrices :
— les opérations  coefficient par coefficient .
— les opérations matricielles classiques.
Pour la somme, ces opérations sont les mêmes puisque que sommer deux matrices, c’est sommer
chaque coefficient des deux matrices entre-eux. En revanche, si on travaille avec le produit, ce n’est
pas la même opération que de faire le produit de chaque coefficient des deux matrices ou de faire le
produit matriciel des deux matrices. Python est capable de faire les deux, il suffit de lui donner la
bonne commande et de faire attention aux compatibilités de dimension.

Toutes les opérations usuelles (i.e. +,−, ∗, / et ∗∗) s’entendent coefficient par coefficient (ce ne sont
donc pas, pour les 3 dernières, des opérations mathématiques classiques). De même les opérations de
comparaison (i.e. ==, >, <, <=, >= et ! =) s’entendent coefficient par coefficient et renvoient donc
une matrice.

Exercice 6. Que vont afficher les commandes suivantes :

print(np.eye(3)>0)
print(np.array([[1], [2], [3]])*np.ones([3,1]))

Exercice 7. Que va retourner le programme suivant :

3
import numpy as np
A = np.ones((3,2))
B = 2*np.ones((1,2))
A[0] = B
A[1] = 2*A[1]
A[2] =A[2]+1
print(A)

A retenir : On constate donc que Python comprend l’instruction A+1 (qui n’est mathématiquement
pas homogène !) de la manière suivante : ”ajouter 1 à tous les coefficients de A”. C’est la même chose
pour la division par un nombre. Testez le programme suivante pour bien comprendre :

import numpy as np
A=np.ones([2,2])
B=A+3
C=B/4
print(A,B,C)

Le produit matriciel peut être effectué à l’aide de la commande np.dot. La syntaxe pour effectuer
le produit de 2 matrices A et B est M=np.dot(A,B).

Exercice 8. Ecrire une fonction puissance(A,n) qui permet de calculer la puissance nème de la
matrice carrée A (pour n ≥ 1).

5. Fonctions et matrices

Fonctions d’une matrice

Les fonctions de la librairie numpy vues dans un TP précédent s’appliquent à des variables numériques
ou directement des tableaux. Par exemple, la séquence d’instructions suivantes :

import numpy as np
m1 = np.array([[1,np.e],[2,3]])
m = np.log(m1)

affecte à la matrice m la matrice

 
0 1
.
ln(2) 1

Les fonctions matricielles

Les fonctions au programme sont, pour une matrice A :
ˆ np.transpose(A) qui renvoie la transposée de A.
ˆ np.shape(A) qui renvoie un couple de nombre correspondant aux nombres de lignes et de co-
lonnes de A. Pour avoir le nombre de ligne, on pourra donc utiliser la commande np.shape(A)[0]
et pour avoir le nombre de lignes, np.shape(A)[1].
ˆ np.size(A) qui renvoie le nombre d’éléments dans A (donc son nombre de lignes multiplié par
son nombre de colonnes).
ˆ np.sum(A) qui renvoie la somme de tous les coefficients de A.

4
 ˆ np.cumsum(A) qui renvoie une matrice de la même taille que A dont chaque coefficient est la
somme cumulées des coefficients de A (lue en ligne).
ˆ np.mean(A) qui renvoie la moyenne des coefficients de A.
ˆ np.max(A) qui renvoie le maximum des coefficients de A.
ˆ np.min(A) qui renvoie le minimum des coefficients de A.

Testez ces fonctions avec une matrice A de votre choix pour être certain d’avoir tout bien compris.

Ces fonctions s’appliquent, par défaut, à toute la matrice. Elles peuvent aussi, (sauf pour les deux
premières) s’appliquer ligne par ligne (on utilisera alors l’instruction np.blabla(m,1)) ou colonne par
colonne (on utilisera alors l’instruction np.blabla(m,0)).

Exercice 9. Qu’affiche le programme suivant ?

a=np.array([[3,1,0],[5,11,-1]])
print(np.mean(a,0))
print(np.cumsum(a,1))

A=np.ones([2,2])
B=np.eye(2,2)
print(A==B)
print(np.sum.(A==B))

A retenir : Si on utilise la commande np.sum avec une matrice de booléens, Python transforme,
pour son calcul, les False en 0 et les True en 1. Il est aussi possible de transformer une matrice de
booléen en une matrice de 1 et de 0 en utilisant la commande A.astype(int).

Exercice 10. Écrire une fonction egalite(A,B) qui renvoie True si deux matrices A et B sont égales
et False sinon.

Enfin, il existe une librairie numpy.linalg plus spécifiquement dédiée à l’algèbre linéaire. On
l’importe via l’instruction import numpy.linalg as al. Les fonctions au programme sont, pour une
matrice A :
ˆ al.inv(A) qui calcule l’inverse de A si elle existe et renvoie un message d’erreur sinon.
ˆ al.rank(A) qui calcule le rang de A.
ˆ al.matrix_power(A, n) qui calcule la puissance n-ème de A (si A est une matrice carrée !).

Testez ces commandes sur une matrice A de votre choix pour être certain de bien tout comprendre.

Une dernière commande, pour résoudre des systèmes

Dans la bibliothèque np.linalg, on trouve aussi la commande al.solve qui sert à résoudre des
systèmes linéaires. En effet, la commande al.solve(A,B) (avec A une matrice rectangle de taille (n, p)
et B une matrice colonne de taille n) résout l’équation matricielle AX = B.

Exercice 11. Comment utiliser Python pour résoudre le système linéaire suivant ?

 2x + 3y + 5z=8
S= 4x + y + 2z =3
x + y + 5z =1


5
 5. A vous de jouer !

Exercice 12. 1. Écrire une fonction matprod qui effectue le produit de deux matrices lorsque
c’est possible et vous signale l’erreur dans le cas contraire.
2. Écrire une fonction mattrace qui calcule la trace d’une matrice carrée, c’est-à-dire la somme
des coefficients diagonaux de cette matrice.
3. Écrire une fonction danstab qui teste si un élément x appartient à une matrice A.

 
1 0 1
Exercice 13. Soit A la matrice définie par : A = 0 1 0. Calculer An pour tout n ∈ N.
0 0 1
n
On pourra conjecturer la forme de A à l’aide de Python.

Exercice 14. Quelle matrice est créée par cette fonction ?

def =mystere(n) :
P=zeros([n,n]);
for i in range(1, n+1):
P[i,i]=1
P[i,1]=1
for i in range(3, n+1):
for j in range(2, n+1):
P[i,j]=P[i-1,j-1]+P[i-1,j]
return P