Programmation en Python
Matrices et calcul matriciel avec pylab
Pylab: bibliothèque scientifique pour python
La bibliothèque pylab permet d'utiliser les bibliothèques numpy et matplotlib qui forunissent des fonctions scientifiques avancées à python.Il suffit d'importer pylab via la commande
from pylab import *
On peut alors, entre autre, définir, manipuler, calculer, … des matrices.
Définition d'une matrice
La définition est l'utilisation des matrices, le calcul matriciel notamment, est très proche de la syntaxe Matlab.Matrice ligne
On définit une matrice ligne par la commande suivante:M = array([1,2,3])
On accède alors aux éléments de la matrice comme on ceux d'une liste, par exemple
print(M[1])
M[1]=18
print(M)
Attention: en python la numérotation commence à 0 et ainsi, M[1] est le 2ème élément de la matrice.
Matrice 2D, ou tableau bidimensionnel
Une matrice, ou tableau de nombres, en 2D est une liste de listes donnée en argument de la fonctionarray(), par exemple
M = array([[1,2,3], [4,5,6]])
On manipule les éléments de la matrice comme ceux d'une liste de listes, par exemple
M = array([[1,2,3], [4,5,6]])
print(M)
print(M[1][2])
M[1][2]=18
print(M)
# ou
print(M[0,1])
M[0,1]=27
print(M)
Dimension d'une matrice: size & shape
La commande size renvoie le nombre d'éléments de la matrice, tandis que shape renvoie les dimensions (nombre de lignes, colonnes, …), par exemple
M = array([1,2,3])
print(size(M))
print(shape(M))
print('-----')
M = array([[1,2,3], [4,5,6]])
print(size(M))
print(shape(M))
Pour une matrice 2D, le nombre d'éléments d'une matrice est aussi simplement le produit de ses dimensions:
M = array([[1,2,3], [4,5,6]])
print(size(M))
n,m=shape(M)
print(n*m)
Manipulation de matrices et tableaux, extraction, slicing
On peut avoir besoin d'extraire d'une matrice une seulement de celle-ci.On a vu juste avant comment extraire un seul élément, en indiquant sa position, ligne et colonne.
On peut aussi en extraire une plus grande partie, un certain nombre de lignes et de colonnes. On indique pour ce faire la liste des lignes et colonnes à extraire, par exemple pour extraire les colonnes 1 et 3 de la 1ère ligne seulement:
M = array([[1,2,3,4], [5,6,7,8]])
print(M)
C=[1,3]
L=1
print(M[L,C])
Pour extraire (presque) toutes les lignes entre deux entiers, on peut programmer:
M = array([[1,2,3,4], [5,6,7,8],[9,10,11,12]])
print(M)
C=[1,3]
print(M[0:2,C])
enfin, si on veut que notre sélection s'étende depuis le début ou jusqu'à la fin on n'indique rien resperctivement à gauche ou à droite des deux points:
M = array([[1,2,3,4,5], [6,7,8,9,10],[11,12,13,14,15]])
print(M)
print(M[:2,3:])
On extrait ainsi des sous-matrices, des "tranches" de matrices ("slice" en anglais, on fait donc du "slicing" pour le néologisme).
Somme des éléments, en ligne, en colonne
On calcule des sommes avec la fonctionsum (qui existe déjà en python, et dont une autre version, plus efficace, se trouve dans la bibliothèque pylab. Au chargement de pylab, cette version écrasera donc la version standard de python et sera utilisée par défaut).
Par exemple, on calcule facilement la somme de tous les éléments d'une matrice:
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)
print(sum(M))
et, en combinant avec les méthodes de manipulation, extraction, slicing de matrices, on peut additionner tous les termes suivant une ligne ou une colonne par exemple.
Ici, on calcule les sommes des éléments suivant la première ligne puis la somme suivant la deuxième colonne:
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)
#Somme de la 1ère ligne
print(sum(M[0,:]))
#Somme de la 2ème colonne
print(sum(M[1,:]))
Enfin, on peut calculer toutes les sommes en ligne et en colonne (en fait suivant chaque dimension de la matrice qui peut être de dimension plus que 2), en ajoutant en argument à la fonction
sum la dimension suivant laquelle on effectue la somme.
Ainsi,
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)
print(sum(M,0))
# Somme suivant les lignes,
# retourne [12 15 18]
print(sum(M,1))
# Somme suivant les colonnes,
# retourne [ 6 15 24]
Remarque: les fonctions
mean, min et max s'utilisent exactement de la même façon que sum pour calculer des moyennes, minimums ou maximums plutôt que des sommes.
Calcul matriciel
L'addition et la multiplication usuelles sont effectuées terme à terme. Il faut bien sûr dans ce cas que les matrices aient les mêmes dimensions.Par exemple
M = array([[1,2,3], [4,5,6]])
N = array([[7,8,9], [-1,-2,-3]])
print(M*N)
print(M*N)
Le produit matriciel se calcule en utilisant la fonction
dot, par exemple,
M = array([[1,2,3], [4,5,6]])
N = array([[7,8], [9,10],[11,12]])
print(dot(M,N))
Il faut bien sûr là aussi que les dimensions des matrices permettent ce produit.
Puissance d'une matrice
On peut calculer les puissances successives d'une matrice (tant utilisées par exemple dans les graphes et chaînes de Markov), par la boucle:M = array([[1,2], [3,4]])
print(M)
n=10 #puissance voulue
Mp=eye(2)
for i in range(n):
Mp=dot(Mp,M)
print(Mp)
où on a initialisé les calculs par la matrice identité eye
Matrices particulières
Trois matrices particulières peuvent être bien utiles: la matrice identité et les matrices de 0 et de 1 pour éventuellement initialiser des calculs. La matrice identité d'ordre n est la matrice carrée avec des 1 sur la diagonale et des 0 partout ailleurs:I=eye(3)
retourne donc la matrice
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
Les matrices
zeros(n) et ones(n) retournent des matrices carrées d'ordre n et remplies respectivement de 0 ou de 1.
Déterminant et inverse d'une matrice
Le déterminant d'une matrice se calcule en utilisant la fonctiondet(), par exemple
M = array([[1,2], [3,4]])
print(det(M))
et, lorsque ce déterminant n'est pas nul, on peut calculer la matrice inverse par la fonction inv(), par exemple
M = array([[1,2], [3,4]])
print(inv(M))
Savoir calculer l'inverse d'une matrice permet par exemple de résoudre matriciellement des systèmes d'équations.
La résolution d'un système écrit sous la forme matriciel AX=B se fait simplement, lorsque la matrice A est inversible et en multipliant alors à gauche par la matrice inverse, pour obtenir X=A−1B.
Numériquement ce n'est pas la meilleure façon de procéder (la plus rapide, plus efficace, plus précise, …). Dans la bibliothèque pylab, il existe une fonction plus adéquate de résoudre un tel système:
solve, qui s'utilise ainsi,
#X solution de AX=B
X=solve(A,B)
Algèbre linéaire
Les éléments propres d'une matrices s'obtiennent avec la fonctioneig:
M=array([[5,2],[2,8]])
print(M)
D,V=eig(M)
print(D)
D=diag(
Le vecteur D contient les valeurs propres et la matrice V les vecteurs propres.
En particulier, si la matrice est diagonalisable (ce qui est le cas pour la matrice symétrique réelle précédente, cf. théorème spectral), on peut vérifier numériquement la théorie:
M=array([[5,2],[2,8]])
print(M)
D,V=eig(M)
# on retrouve la matrice de départ
# M=P-1DP
print(dot(dot(V,D),inv(V)))
# et inversement
# et on trouve la matrice de diagonale
# avec les valeurs propores
# D=PAP-1
print(dot(dot(inv(V),M),V))