Matrices en Python
Une matrice est une structure de données bidimensionnelle (2D) dans laquelle les nombres sont organisés en lignes et en colonnes.
Définition — Matrice Une matrice de taille n × m contient n lignes et m colonnes. L'élément à la ligne i et la colonne j est noté M[i][j]. En Python, deux approches existent :
- Listes imbriquées — natif, sans import, adapté aux petites matrices
- NumPy — bibliothèque scientifique, opérations vectorisées, recommandée
| Critère | Listes imbriquées | NumPy ndarray |
|---|---|---|
| Import requis | ❌ Non | ✅ import numpy as np |
| Syntaxe des opérations | Boucles manuelles | Opérateurs directs +, *, .T |
| Performance | ⚠️ Lente sur grandes matrices | ✅ Très rapide (code C optimisé) |
| Fonctions mathématiques | ⚠️ Manuelles | ✅ Complètes (det, inv, eig…) |
| Slicing 2D | ⚠️ Limité | ✅ A[i:j, k:l] |
Partie 1 — Matrices avec listes imbriquées
Création et accès
M = [[l00, l01, ...], # ligne 0
[l10, l11, ...], # ligne 1
...]
M[i] # ligne i (retourne une liste)
M[i][j] # élément ligne i, colonne j
M[i][-1] # dernier élément de la ligne iExemple n°1 — Accès aux éléments
M = [[3, 1, 5],
[9, 8, -1],
[10, 12, 2]]
n = len(M) # nombre de lignes = 3
m = len(M[0]) # nombre de colonnes = 3
print(f"M = {M}")
print(f"M[1] = {M[1]}") # 2ème ligne
print(f"M[1][2] = {M[1][2]}") # 3ème élément de la 2ème ligne
print(f"M[0][-1] = {M[0][-1]}") # dernier élément de la 1ère ligne
print(f"Taille : {n} × {m}")
# Extraire la 3ème colonne
col3 = [M[i][2] for i in range(n)]
print(f"Colonne 3 = {col3}") Sortie
M = [[3, 1, 5], [9, 8, -1], [10, 12, 2]] M[1] = [9, 8, -1] M[1][2] = -1 M[0][-1] = 5 Taille : 3 × 3 Colonne 3 = [5, -1, 2]
Initialisation d'une matrice
Exemple n°2 — Créer des matrices initialisées
n, m = 3, 4
# Matrice de zéros
zeros = [[0] * m for _ in range(n)]
print(f"Zéros : {zeros}")
# Matrice identité
I = [[1 if i == j else 0 for j in range(n)] for i in range(n)]
print(f"Identité :")
for ligne in I:
print(f" {ligne}")
# Matrice remplie par compréhension (table de multiplication)
table = [[i * j for j in range(1, 5)] for i in range(1, 4)]
print(f"Table : {table}") Sortie
Zéros : [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] Identité : [1, 0, 0] [0, 1, 0] [0, 0, 1] Table : [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12]]
Erreur fréquente —
[[0]*m]*n ne fonctionne pas ! La multiplication [[0]*m]*n crée n références vers la même ligne, pas n lignes indépendantes :# ❌ Toutes les lignes partagent le même objet !
M = [[0] * 3] * 3
M[0][1] = 9
print(M) # [[0, 9, 0], [0, 9, 0], [0, 9, 0]] ← toutes modifiées !
# ✅ Compréhension — chaque ligne est indépendante
M = [[0] * 3 for _ in range(3)]
M[0][1] = 9
print(M) # [[0, 9, 0], [0, 0, 0], [0, 0, 0]] ← seule la 1ère modifiéeAddition de matrices
Exemple n°3 — Addition (méthode 1 : boucles)
A = [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
B = [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
n, m = len(A), len(A[0])
C = [[0] * m for _ in range(n)]
for i in range(n):
for j in range(m):
C[i][j] = A[i][j] + B[i][j]
print(f"A + B = {C}") Sortie
A + B = [[11, 0, 13], [11, 9, 2], [28, 14, 34]]
Exemple n°4 — Addition (méthode 2 : compréhension)
A = [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
B = [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
n, m = len(A), len(A[0])
C = [[A[i][j] + B[i][j] for j in range(m)] for i in range(n)]
print(f"A + B = {C}") Sortie
A + B = [[11, 0, 13], [11, 9, 2], [28, 14, 34]]
Transposée d'une matrice
Définition — Transposée La transposée d'une matrice A (n×m) est la matrice AT (m×n) obtenue en échangeant lignes et colonnes : AT[j][i] = A[i][j].
Exemple n°5 — Transposée (boucles et compréhension)
A = [[3, 1, 5],
[9, 8, -1],
[10, 12, 2]]
n, m = len(A), len(A[0])
# Méthode 1 : boucles
T1 = [[0] * n for _ in range(m)]
for i in range(n):
for j in range(m):
T1[j][i] = A[i][j]
# Méthode 2 : compréhension (plus concise)
T2 = [[A[j][i] for j in range(n)] for i in range(m)]
print(f"A = {A}")
print(f"Aᵀ = {T1}") Sortie
A = [[3, 1, 5], [9, 8, -1], [10, 12, 2]] Aᵀ = [[3, 9, 10], [1, 8, 12], [5, -1, 2]]
Produit matriciel
Définition — Produit matriciel Le produit C = A × B de A (n×p) et B (p×m) donne une matrice C (n×m) où chaque élément est : C[i][j] = Σk=0p-1 A[i][k] × B[k][j]. La condition est que le nombre de colonnes de A = lignes de B.
Exemple n°6 — Produit matriciel (triple boucle)
A = [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
B = [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
n = len(A) # lignes de A
m = len(B[0]) # colonnes de B
p = len(B) # lignes de B (= colonnes de A)
C = [[0] * m for _ in range(n)]
for i in range(n): # ligne de A
for j in range(m): # colonne de B
for k in range(p):
C[i][j] += A[i][k] * B[k][j]
print(f"A × B = {C}") Sortie
A × B = [[116, 8, 187], [70, -3, 64], [140, 6, 180]]
Complexité — Produit matriciel naïf L'algorithme naïf (triple boucle) a une complexité de O(n³) pour des matrices n×n. Pour de grandes matrices, utiliser NumPy qui implémente des algorithmes optimisés (BLAS/LAPACK) beaucoup plus rapides.
Partie 2 — Matrices avec NumPy
NumPy (Numerical Python) est la bibliothèque de référence pour le calcul scientifique en Python. Elle fournit l'objet ndarray (N-dimensional array) qui permet des opérations matricielles avec une syntaxe concise et des performances élevées.
import numpy as np
A = np.array([[1, 2], [3, 4]]) # depuis une liste
A.shape # (n_lignes, n_colonnes)
A.dtype # type des éléments
A.ndim # nombre de dimensionsCréation de tableaux NumPy
Exemple n°7 — Types de données
import numpy as np
# Entiers (détection automatique)
A = np.array([[1, 2, 3], [3, 4, 5]])
print(f"A (int) :\n{A} dtype={A.dtype}")
# Réels (présence d'un float → tout devient float)
B = np.array([[1.1, 2, 3], [3, 4, 5]])
print(f"B (float) :\n{B} dtype={B.dtype}")
# Forcer le type complexe
C = np.array([[1, 2], [3, 4]], dtype=complex)
print(f"C (complex) :\n{C}") Sortie
A (int) : [[1 2 3] [3 4 5]] dtype=int64 B (float) : [[1.1 2. 3. ] [3. 4. 5. ]] dtype=float64 C (complex) : [[1.+0.j 2.+0.j] [3.+0.j 4.+0.j]]
Exemple n°8 — Fonctions de création spécialisées
import numpy as np
# Matrice de zéros
print(f"zeros(2,3) :\n{np.zeros((2, 3))}")
# Matrice de uns
print(f"ones(3,2) :\n{np.ones((3, 2))}")
# Matrice identité
print(f"eye(3) :\n{np.eye(3)}")
# Depuis arange + reshape
A = np.arange(12).reshape(3, 4)
print(f"arange(12).reshape(3,4) :\n{A}")
# Valeurs régulièrement espacées
L = np.linspace(0, 1, 5)
print(f"linspace(0,1,5) : {L}") Sortie
zeros(2,3) : [[0. 0. 0.] [0. 0. 0.]] ones(3,2) : [[1. 1.] [1. 1.] [1. 1.]] eye(3) : [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] arange(12).reshape(3,4) : [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] linspace(0,1,5) : [0. 0.25 0.5 0.75 1. ]
Accès aux éléments, lignes et colonnes
Exemple n°9 — Indexation 1D et 2D
import numpy as np
A = np.array([[ 1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]])
# Élément unique
print(f"A[0][0] = {A[0][0]}") # ou A[0, 0]
print(f"A[1][2] = {A[1, 2]}") # syntaxe NumPy recommandée
print(f"A[-1][-1] = {A[-1, -1]}")
# Lignes entières
print(f"A[0] = {A[0]}") # 1ère ligne
print(f"A[-1] = {A[-1]}") # dernière ligne
# Colonnes entières
print(f"A[:,0] = {A[:, 0]}") # 1ère colonne
print(f"A[:,2] = {A[:, 2]}") # 3ème colonne
print(f"A[:,-1] = {A[:, -1]}") # dernière colonne Sortie
A[0][0] = 1 A[1][2] = 9 A[-1][-1] = 19 A[0] = [ 1 4 5 12] A[-1] = [-6 7 11 19] A[:,0] = [ 1 -5 -6] A[:,2] = [ 5 9 11] A[:,-1] = [12 0 19]
Découpage (slicing) NumPy
A[debut_ligne:fin_ligne, debut_col:fin_col]
A[:, j] # colonne j entière
A[i, :] # ligne i entière
A[i:j, k:l] # sous-matriceExemple n°10 — Slicing sur matrice
import numpy as np
A = np.array([[ 1, 4, 5, 12, 14],
[-5, 8, 9, 0, 17],
[-6, 7, 11, 19, 21]])
print(f"A[:2, :4] :\n{A[:2, :4]}") # 2 premières lignes, 4 premières colonnes
print(f"A[:1, :] :\n{A[:1, :]}") # 1ère ligne, toutes colonnes
print(f"A[:, 2] : {A[:, 2]}") # toutes lignes, 3ème colonne
print(f"A[:, 2:5] :\n{A[:, 2:5]}") # toutes lignes, colonnes 3 à 5 Sortie
A[:2, :4] : [[ 1 4 5 12] [-5 8 9 0]] A[:1, :] : [[ 1 4 5 12 14]] A[:, 2] : [ 5 9 11] A[:, 2:5] : [[ 5 12 14] [ 9 0 17] [11 19 21]]
Opérations matricielles avec NumPy
Exemple n°11 — Addition, multiplication et transposée
import numpy as np
A = np.array([[3, 1, 5], [9, 8, -1], [10, 12, 2]])
B = np.array([[8, -1, 8], [2, 1, 3], [18, 2, 32]])
# Addition élément par élément
print(f"A + B :\n{A + B}")
# Multiplication élément par élément (⚠️ pas le produit matriciel)
print(f"A * B :\n{A * B}")
# Produit matriciel — méthode dot()
print(f"A @ B :\n{A @ B}") # opérateur @ (Python 3.5+)
print(f"A.dot(B):\n{A.dot(B)}") # méthode équivalente
# Transposée
print(f"Aᵀ :\n{A.T}")
# Multiplication scalaire
print(f"A * 2 :\n{A * 2}") Sortie
A + B : [[11 0 13] [11 9 2] [28 14 34]] A * B : [[ 24 -1 40] [ 18 8 -3] [180 24 64]] A @ B : [[116 8 187] [ 70 -3 64] [140 6 180]] Aᵀ : [[ 3 9 10] [ 1 8 12] [ 5 -1 2]] A * 2 : [[ 6 2 10] [18 16 -2] [20 24 4]]
Attention —
* ≠ produit matriciel En NumPy, A * B effectue la multiplication élément par élément (produit de Hadamard), pas le produit matriciel. Pour le produit matriciel, utiliser A @ B ou A.dot(B):A * B # ❌ produit élément par élément
A @ B # ✅ produit matriciel (recommandé, Python 3.5+)
A.dot(B) # ✅ produit matriciel (compatible toutes versions)Exemple n°12 — Fonctions utilitaires NumPy
import numpy as np
A = np.array([[3., 1., 5.],
[9., 8., -1.],
[10., 12., 2.]])
print(f"Shape : {A.shape}") # (3, 3)
print(f"Dtype : {A.dtype}") # float64
print(f"Sum : {A.sum()}") # somme de tous les éléments
print(f"Sum col: {A.sum(axis=0)}") # somme par colonne
print(f"Sum lig: {A.sum(axis=1)}") # somme par ligne
print(f"Mean : {A.mean():.4f}") # moyenne
print(f"Max : {A.max()}")
print(f"Min : {A.min()}")
print(f"Det : {np.linalg.det(A):.2f}") # déterminant Sortie
Shape : (3, 3) Dtype : float64 Sum : 49.0 Sum col: [22. 21. 6.] Sum lig: [ 9. 16. 24.] Mean : 5.4444 Max : 12.0 Min : -1.0 Det : -22.00
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.