Initiation au calcul matriciel avec NumPy

Les matrices avec NumPy et Matplotlib

Denis Hulo

Objectif : apprendre à manipuler des matrices avec NumPy (création, opérations de base, inversion, déterminant, résolution de systèmes, valeurs propres) et à les représenter visuellement avec Matplotlib.

Niveau requis : confirmé — connaissances de base en Python et en vecteurs sont utiles.

- Titre : Initiation au calcul matriciel avec NumPy

- Auteur : Denis Hulo

- Parution : 2 octobre 2025

- Public visé :

- Licence : Le contenu de cet article est rédigé par Denis Hulo et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- I. Introduction

- II. Matrice — définition et représentation

- II-A. Créer une matrice avec NumPy

- II-B. Accès aux éléments et slicing

- III. Opérations élémentaires sur les matrices

- III-A. Addition et multiplication par un scalaire

- III-B. Transposée

- III-C. Produit matriciel (dot)

- III-D. Matrice identité et matrice zéro

- IV. Algèbre linéaire numérique

- IV-A. Déterminant et inverse

- IV-B. Rang, valeurs propres et vecteurs propres

- IV-C. Résolution d'un système linéaire

- V. Visualisation et applications pratiques

- V-A. Afficher une matrice (heatmap)

- V-B. Transformation linéaire : application géométrique

- VI. Exemples guidés (scripts complets)

- VI-1. Script : inverse et vérification

- VI-2. Script : résolution d'un système et comparaison LLS

- VII. Bonnes pratiques et pièges numériques

- VIII. Conclusion

- IX. Téléchargement

- X. Remerciements

I - Introduction

Ce tutoriel présente les notions de base du calcul matriciel en Python en s’appuyant sur la bibliothèque NumPy et quelques outils de visualisation proposés par Matplotlib. Ces opérations constituent le socle de l’algèbre linéaire numérique, largement utilisée en data science, en apprentissage automatique, en simulation et en physique numérique.

Dans la continuité d’une première initiation consacrée au calcul vectoriel avec NumPy, nous aborderons : la représentation d’une matrice, les opérations élémentaires (addition, multiplication par un scalaire), le produit matriciel, la transposée, la matrice identité, le calcul du déterminant et de l’inverse, la résolution de systèmes linéaires, l’étude des valeurs propres ainsi que des techniques de visualisation (heatmap, transformations linéaires simples).

II - Matrice — définition et représentation

En algèbre linéaire, une matrice est un tableau rectangulaire de nombres disposés en lignes et en colonnes. Une matrice m×n possède m lignes et n colonnes.

II-A - Créer une matrice avec NumPy

Une matrice s'implémente naturellement avec un tableau NumPy 2D (ndarray de dimension 2) :

>>> import numpy as np

>>> A = np.array([[1, 2, 3],
...               [4, 5, 6]])
>>> A
array([[1, 2, 3],
[4, 5, 6]])

Vous pouvez vérifier la forme (nombre de lignes et de colonnes) avec A.shape :

>>> A.shape
(2, 3)

II-B - Accès aux éléments et slicing

Nous allons maintenant montrer comment accéder aux différents éléments d’une matrice à l'aide de l'indexation.

A[i, j] désigne l'élément de la (i+1)-ème ligne et de la (j+1)-ème colonne (indexation commençant à 0) :

>>> A[0,1]
2

# première ligne
>>> A[0]
array([1, 2, 3])

# première colonne (utiliser le slicing)
>>> A[:,0]
array([1, 4])

III - Opérations élémentaires sur les matrices

Voyons ensuite comment réaliser les opérations de base sur les matrices avec NumPy.

III-A - Addition et multiplication par un scalaire

Comme pour les vecteurs, les opérations élémentaires se font composante par composante :

>>> B = np.array([[10, 20, 30],
...               [40, 50, 60]])
>>> A + B
array([[11, 22, 33],
[44, 55, 66]])

>>> 2 * A
array([[ 2,  4,  6],
[ 8, 10, 12]])

III-B - Transposée

La transposée d'une matrice A, notée AT, s’obtient en transformant ses lignes en colonnes (et inversement).

>>> A.T
array([[1, 4],
[2, 5],
[3, 6]])

III-C - Produit matriciel (dot)

Produit matriciel classique : si A est de taille (m×p) et B de taille (p×n), le produit A·B existe et donne une matrice (m×n).

En NumPy, on utilise np.dot(A, B) ou l'opérateur A @ B :

>>> B = np.array([[1, 0],
...               [0, 1],
...               [1, 1]])  # taille (3,2)
>>> A.shape, B.shape
((2, 3), (3, 2))

>>> A @ B
array([[ 4,  5],
[10, 11]])

Attention aux dimensions : la compatibilité des tailles est essentielle.

III-D - Matrice identité et matrice zéro

Création d'une matrice identité et d'une matrice nulle :

>>> np.eye(3)   # identité 3x3
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

>>> np.zeros((2,3))
array([[0., 0., 0.],
[0., 0., 0.]])

IV - Algèbre linéaire numérique

Nous allons découvrir dans cette section les bases de l’algèbre linéaire à l’aide de NumPy.

IV-A - Déterminant et inverse

Prenons par exemple une matrice carrée :

Pour les matrices carrées, NumPy (via le sous-module linalg) permet de calculer le déterminant et l'inverse :

>>> import numpy.linalg as la

>>> M = np.array([[2, 1],
...               [3, 4]])
>>> la.det(M)
5.0

>>> la.inv(M)
array([[ 0.8, -0.2],
[-0.6,  0.4]])

Vérification : M @ la.inv(M) donne (approximativement) la matrice identité.

Une matrice est inversible uniquement si son déterminant est non nul. Toutefois, pour les matrices mal conditionnées, l’inversion numérique peut s’avérer instable ; il est alors préférable d’utiliser des méthodes directes, comme les décompositions (LU, QR), pour résoudre les systèmes.

IV-B - Rang, valeurs propres et vecteurs propres

En algèbre linéaire, le rang d’une matrice ainsi que ses valeurs propres et vecteurs propres jouent un rôle fondamental. En Python, on peut les calculer à l’aide du sous-module linalg de NumPy :

>>> la.matrix_rank(M)
2

>>> vals, vecs = la.eig(np.array([[2, 0],
...                              [0, 3]]))
>>> vals
array([2., 3.])
>>> vecs
array([[1., 0.],
[0., 1.]])

Les valeurs propres (eigenvalues) renseignent sur les facteurs d'étirement pour la transformation linéaire associée à la matrice.

IV-C - Résolution d'un système linéaire

Soit le système d'équations linéaires à résoudre :

Cela revient à poser Ax = b avec :

Et :

Pour résoudre ce système, on utilise la.solve(A, b) lorsque A est une matrice carrée et non singulière :

>>> A = np.array([[3, 1],
...               [1, 2]])
>>> b = np.array([9, 8])
>>> x = la.solve(A, b)
>>> x
array([2., 3.])

# vérification
>>> A @ x
array([9., 8.])

Si le système est surdéterminé (plus d’équations que d’inconnues), la solution peut être approchée grâce à la méthode des moindres carrés : np.linalg.lstsq(A, b, rcond=None).

V - Visualisation et applications pratiques

Dans cette section, nous allons montrer comment représenter visuellement ces matrices à l'aide de Matplotlib.

V-A - Afficher une matrice (heatmap)

Pour visualiser les valeurs d'une matrice, on peut utiliser plt.imshow() ou plt.pcolormesh() :

import numpy as np
import matplotlib.pyplot as plt

M = np.random.rand(10, 10)  # matrice 10x10
plt.figure(figsize=(6,5))
plt.title("Heatmap d'une matrice 10x10")
plt.imshow(M, origin='lower', aspect='auto')
plt.colorbar(label='valeur')
plt.show()

Lors de son exécution, le script affiche une Heat map (carte thermique) :

Cette visualisation est utile pour repérer patterns, diagonales dominantes, blocs, etc.

V-B - Transformation linéaire : application géométrique

Une matrice 2×2 définit une transformation du plan. On peut visualiser l'image d'une grille ou d'une forme simple :

import numpy as np
import matplotlib.pyplot as plt

# matrice de transformation
T = np.array([[1.5, 0.5],
[0.2, 1.2]])

# grille de points
X, Y = np.meshgrid(np.linspace(-2,2,9), np.linspace(-2,2,9))
pts = np.vstack([X.ravel(), Y.ravel()])  # shape (2, N)

# application de la transformation
pts_T = T @ pts

plt.figure(figsize=(6,6))
plt.scatter(pts[0], pts[1], label='original', s=10)
plt.scatter(pts_T[0], pts_T[1], label='transformé', s=10)
# tracé des vecteurs d'origine vers image
for i in range(pts.shape[1]):
plt.plot([pts[0,i], pts_T[0,i]], [pts[1,i], pts_T[1,i]], linewidth=0.5)
plt.legend()
plt.axis('equal')
plt.title("Transformation linéaire définie par T")
plt.show()

Le code affiche le graphique :

Cette technique illustre visuellement l'effet d'une matrice (dilatation, rotation, cisaillement).

VI - Exemples guidés (scripts complets)

Nous présentons pour terminer deux scripts complets servant d’exemples guidés de calcul matriciel en algèbre linéaire.

VI-1 - Script : inverse et vérification

import numpy as np
import numpy.linalg as la

A = np.array([[4., 7.],
[2., 6.]])

detA = la.det(A)
print("det(A) =", detA)

if abs(detA) > 1e-12:
A_inv = la.inv(A)
print("A @ A_inv =\n", np.round(A @ A_inv, 8))
else:
print("Matrice singulière, pas d'inverse.")

Le code affiche :

det(A) = 10.000000000000002
A @ A_inv =
[[ 1. -0.]
[ 0.  1.]]

VI-2 - Script : résolution d'un système et comparaison LLS

Soit le système d'équations linéaires à résoudre :

Cela revient à poser Ax = b, avec :

Et :

import numpy as np
import numpy.linalg as la

A = np.array([[1., 1.],
[1., 2.],
[1., 3.]])  # 3x2 (surdéterminé)
b = np.array([6., 9., 12.])

# solution par moindres carrés
x, residuals, rank, s = la.lstsq(A, b, rcond=None)
print("Solution LLS x =", x)
print("Résidus :", residuals)

# Si A carrée, on utiliserait la.solve(A,b)

Lors de son éxécution, le script affiche :

Solution LLS x = [3. 3.]
Résidus : [7.88860905e-31]

VII - Bonnes pratiques et pièges numériques

- Privilégier les routines de la bibliothèque (numpy.linalg.solve, numpy.linalg.lstsq, numpy.linalg.eig) plutôt que d'implémenter soi-même la résolution pour des raisons de robustesse et de performance.

- Utilisez les opérations vectorisées NumPy plutôt que des boucles Python. Cela rend le code plus concis, plus lisible et souvent beaucoup plus rapide.

- Attention à la condition numérique : une matrice mal conditionnée amplifie les erreurs de calcul — vérifier numpy.linalg.cond(A).

- Pour de grandes matrices creuses (contenant beaucoup de zéros), utiliser scipy.sparse et les algorithmes conçus pour matrices creuses.

VIII - Conclusion

Nous avons passé en revue les opérations fondamentales du calcul matriciel avec NumPy et montré comment les appliquer à des problèmes concrets : inversion de matrices, résolution de systèmes, calcul des valeurs propres et visualisation.

Ce tutoriel s’inscrit comme une suite naturelle de l’introduction au calcul vectoriel (manipulation et visualisation). Pour approfondir et mieux comprendre la correspondance entre vecteurs et matrices, vous pouvez vous référer à l’article initial, qui propose de nombreux exemples pratiques.

IX - Téléchargement

Module compressé contenant les scripts fournis en exemples dans le corps de l'article.

X - Remerciements

Je tiens à remercier ... pour ses différentes suggestions, ainsi que pour sa relecture.

Sources et lectures recommandées

- NumPy — linear algebra (linalg)

- Matplotlib — guide d'utilisation

- Algèbre linéaire

- Heat map (carte thermique)