Algèbre

15 minutes de Python

Numpy : matrices (création, extraction, opérations)

Thème : Algèbre

Niveau : ECG1–ECG2

Année : Maths appliquées, Maths approfondies

Objectif : maîtriser les commandes de base de numpy pour manipuler des matrices : création, extraction/modification d’éléments, somme, trace, tests simples, produit * et produit matriciel np.dot

Les commandes à connaître

On utilise les fonctions de la bibliothèque numpy pour manipuler rapidement des tableaux et des matrices. Dans ce qui suit, on importe la bibliothèque sous le nom np.

import numpy as np

1) Créer des vecteurs et des matrices

np.array([...]) : créer un tableau d'une ligne (un vecteur) à partir d’une liste Python (les coefficients sont séparés par des virgules.
np.array([[ligne_1],[ligne_2],...,[ligne_p]]) : créer un tableau à deux dimensions (une matrice) à partir d’une liste Python (les coefficients d'une ligne sont séparés par des virgules).
np.zeros([n,p]) : matrice comportant \( n \) lignes et \( p \) colonnes (numérotées à partir de \( 0 \)) dont les coefficients sont tous égaux à \( 0 \).
np.ones([n,p]) : : matrice comportant \( n \) lignes et \( p \) colonnes (numérotées à partir de \( 0 \)) dont les coefficients sont tous égaux à \( 1 \).
np.eye(n) : matrice identité \(I_n\) carrée d'ordre \( n \).

2) Extraire / modifier

A[i,j] : coefficient d’indice \((i,j)\) (indices commençant à 0).
A[i,:] : ligne \(i\).
A[:,j] : colonne \(j\).
On peut affecter : A[i,j]=... ou A[:,j]=....

3) Opérations classiques

A+B, A-B, c*A : opérations terme à terme.
A*B : produit terme à terme (attention : ce n’est pas le produit matriciel).
np.dot(A,B) : produit matriciel.
np.sum(A) : somme de tous les coefficients de A.
f(A) : matrice dont les coefficients sont les images par \( f \) des coefficients de A (si \( f \) est une fonction numérique réelle).
np.transpose(A) : transposée de \( A \).

Exemple

import numpy as np

A = np.array([[1, 2, 0],[0, 1, 3],[2, 0, 1]])

# Extraction / modification

# coefficient (0,2) (l'indexation commence à 0)
a13 = A[0, 2]          
# colonne d’indice 1 (= deuxième colonne)
col2 = A[:, 1]
# on modifie un coefficient
A[2, 1] = -5           

# Créations de matrices particulières
B = np.eye(3)
C = np.ones([3,3])

# Sommes, Produits : * (terme à terme) vs dot (matriciel)
D = B+C
E = A * D
F = np.dot(A, D)


print("a13 =", a13)
print("col2 =", col2)
print("D =", E)
print("E =", E)
print("F =", F)

Explication

Dans l’exemple, on commence par créer une variable A avec np.array, dont les coefficients sont ceux de la matrice : \[ A = \begin{pmatrix} 1 & 2 & 0 \\ 0 & 1 & 3 \\ 2 & 0& 1 \end{pmatrix} \]

Chaque liste [...] de nombres est une ligne de \( A \), les lignes sont séparées par des virgules.

Ensuite on extrait et modifie des coefficients de A :

a13 reçoit A[0,2], qui est le coefficient de la première ligne (numéro 0) et de la troisième colonne (numéro 2) : un un tableau numpy, on se souviendra que les lignes et les colonnes sont numérotées à partir de 0.
col2 reçoit les coefficients la deuxième colonne de A.
A[2,1] (coefficient de la troisième ligne et de la deuxième colonne de A est modifié et reçoit la valeur \( -5\).

Le programme crée ensuite deux nouvelles variables :

B reçoit np.eye(3), c'est-à-dire la matrice identité d'ordre \( 3 \).
C reçoit np.ones([3,3]), c'est-à-dire la matrice carrée d'ordre \( 3 \) dont les coefficients sont tous égaux à \( 1\).

Le programme fait alors des calculs avec ces matrices :

D reçoit la matrice \( B+C\),
E reçoit la matrice dont les coefficients sont les produits termes à termes des coefficients de \( A \) et \( D\), c'est-à-dire, en notant \( A = (a_{i,j}) \) et \( D= (d_{i,j} ) \), E reçoit la matrice \( (a_{i,j} d_{i,j} ) \).
F reçoit la matrice \( A D\), c'est-à-dire le produit matriciel des matrices \( A \) et \( D\), dans cet ordre.

Trois commandes utiles aujourd’hui

Clique sur une carte pour voir l’instruction utile.

Déterminer le format d’une matrice

Somme des coefficients d’un tableau

Comparer deux valeurs

Un exercice pour vérifier ta maîtrise

On considère la matrice réelle carrée d’ordre 3 définie par

\[ A = \begin{pmatrix} 1 & 2 & 3 \\ 2 & 5 & 4 \\ 3 & 4 & 6 \end{pmatrix} \]

On souhaite étudier cette matrice à l’aide de Python et de la bibliothèque numpy. Compléter le script pour qu’il permette de répondre aux questions suivantes :

Créer, à l’aide de numpy, la matrice A.
Afficher le format de la matrice A (nombre de lignes et nombre de colonnes).
Calculer et afficher la trace de A, c’est-à-dire la somme de ses coefficients diagonaux.
Calculer la matrice A^2 à l’aide du produit matriciel.
À l’aide d’une boucle, calculer la matrice A^n pour un entier n saisi par l’utilisateur.

import numpy as np

# création de la matrice A
A = np.array([[1,2,3],[2,5,4],[3,4,6]])

# calcul de la trace
tr = 0
for i in range(3):
     tr = tr + A[i,i] 
print(tr)

# format de la matrice A
n,p = np.shape(A)
print("Nombre de lignes = ",n)
print("Nombre de colonnes = ",n)

# affichage de A^2
B = np.dot(A,A)
print(B)


# calcul de A^n
n = int(input("n = "))
C = np.eye(3)
for k in range(n):
    C = np.dot(C,A)
print(C)

Et pour quelques minutes de plus…

Prendre en main la programmation, pas à pas.

Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.

L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.

L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.

Niveau 1 Analyser un code

Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits. L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.

Niveau 2 Compléter un code

Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro. Le squelette du programme est fourni : il te reste à compléter certaines instructions pour que le code fonctionne correctement. Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.

Niveau 3 Écrire un code complet

Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne. Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script. C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.