You are on page 1of 3

Comment crer une matrice en Python ?

I)

Utilisation du module numpy.

Il existe un module additionnel Python nomm numpy permettant de crer et


d'effectuer des oprations sur les matrices. Ce module est librement tlchargeable sur
internet l'adresse suivante : http://numpy.scipy.org/
Les instructions dcrites ci-dessous ne reprsentent qu'une partie des possibilits de ce
module.
Pour utiliser ce module il faut en tte de votre programme saisir : from numpy import*
1. Crer des matrices.
a. Crer une matrice en saisissant une une les valeurs de chacun des termes. L'instruction est "array".
array([(. . .,. . ., ,. . .),(. . .,. . ., ,. . .), ,(. . .,. . ., ,. . .)]
1re ligne
2me ligne
dernire ligne
Le sparateur pour les diffrentes valeurs ou pour les diffrentes lignes est ",".
1 2 3
exemple : array([(1,2,3),(4,5,6)])
cre la matrice 23 : 4 5 6
rsultat l'affichage:
[[1 2 3]
[4 5 6]]
b. Crer une matrice ne contenant que des 0, ou bien que des 1. Les instructions sont "zeros" et "ones".
Pour une matrice une seule ligne :
zeros(nombre de colonnes)
et
ones(nombre de colonnes)
Pour les autres matrices :
zeros(nombre de lignes,nombre de colonnes) et
ones(nombre de lignes,nombre de colonnes)
exemples. zeros(5)
cre la matrice 15 : (0 0 0 0 0)
1 1 1
ones((2,3)) cre la matrice 23 : 1 1 1
c. Crer une matrice avec des valeurs spares d'un pas rgulier. L'instruction est "arange".
Pour les matrices avec les entiers conscutifs de 0 n-1 :
les matrices une seule ligne et contenant les entiers de 0 n-1:
arange(n)
les autres matrices ab et contenant les entiers de 0 n-1:
arange(n).reshape(a,b)
Pour les matrices avec les rels dbutants d, finissant f et spars d'un pas p:
les matrices une seule ligne :
arange(d,f,p)
les autres matrices ab :
arange(d,f,p).reshape(a,b)
exemples : arange(4)
cre la matrice 14 : (0 1 2 3)
0 1 2
arange(6).reshape(23)
cre la matrice 23 : 3 4 5
arange(1,16,4.2)
cre la matrice 14 : (1 5.2 9.4 13.6)
5.2
1
arange(1,16,4.2).reshape(2,2) cre la matrice 22 : 9.4 13.6
d. Crer une matrice ab diagonale avec des 1. L'instruction est "eye" avec la syntaxe :
exemples :

1 0 0
eye(2,3) cre 0 1 0 ,

1 0 0
eye(3,3) cre 0 1 0 ,
0 0 1

eye(4,3)

eye(a,b).
10 01 00
cre 0 0 1
0 0 0

2. Accder aux termes d'une matrice.


Il faut retenir que les lignes et les colonnes sont numrotes partir de 0.
a. Accder un terme d'une matrice A. Syntaxe : A[numro de ligne, numro de colonne]
1 2 3
exemple : Si A = 4 5 6 alors
A[1,2] correspond au terme 6
b. Accder une ligne d'une matrice A. Syntaxe : A[numro de ligne]
1 2 3
exemple : Si A = 4 5 6 alors
A[1]
correspond la ligne n1, rsultat :

[4 5 6]

c. Accder une colonne d'une matrice A. Syntaxe :


A[:,numro de colonne]
1 2 3
exemple : Si A = 4 5 6 alors
A[:,1]
correspond la colonne n 1, rsultat :

[2 5]

3. Oprations sur les matrices.


1. 2. 3.
a. Effectuer une mme opration sur tous les termes d'un mme matrice. Avec A = 4. 5. 6. .
2. 4. 6.
Multiplier tous les termes :
2*A
donne 8. 10. 12.
0.5 1. 1.5
Diviser tous les termes :
A/2
donne 2. 2.5 3.
0. 1. 2.
Additionner ou soustraire tous les termes : A-1
donne 3. 4. 5.
1. 4. 9.
Mettre tous les termes au carr :
A**2
donne 16. 25. 36.
0.84147098 0.90929743 0.14112001
Calculer le sinus de tous les termes :
sin(A)
donne -0.7568025 -0.95892427 -0.2794155

b. Effectuer des oprations avec des matrices.


1. 3.
1. 2. 3.
3. 2. 4.
3. 2.
Avec A = 4. 5. 6. , B = 1. 5. 6. , C = 2. 4. et D = 1. 2. .
2. 5.
3. 4. 12.
donne 4. 25. 36.
11. 26.
Multiplier deux matrices :
dot(A,C)
donne 26. 62.
4. 4. 7.
Additionner ou soustraire deux matrices :
A+B
donne 5. 10. 12.
0.5 -0.5
Inverser une matrice :
linalg.inv(D) donne -0.25 0.75
3. 1.
Transpose d'une matrice :
D.transpose() donne 2. 2.
Pour calculer une puissance d'une matrice, voici une fonction que l'on peut dfinir en tte de programme :
def puissance(mat,exp):
m=mat
for i in range(1,exp):
mat=dot(mat,m)
return mat
11. 10.
ainsi, puissance(D,2)
donne 5. 6.
Effectuer le produit, terme terme, de deux matrices :

A*B

II) Crer une matrice avec les listes.


On peut crer une matrice avec deux boucles "for" imbriques. On obtient alors des listes de listes.
Etant donn l'existence du module numpy, nous ne proposerons pas ici la programmation pour raliser les
diffrentes oprations sur ces matrices. Cela peut ventuellement faire l'objet d'exercices.
4 0 0 0
Exemple. On veut crer la matrice 3 lignes par 4 colonnes : 0 0 8 0
0 0 0 0
M = [[0 for j in range(0,4)] for i in range(0,3)]
M[0][0]=4
M[1][2]=8
print M
Rsultat:

[[4, 0, 0, 0], [0, 0, 8, 0], [0, 0, 0, 0]]

Commentaires :
"for j in range(0,4)" cre les colonnes numrotes de 0 3, et " for i in range(0,3)" cre les
lignes numrotes de 0 2.
L'lment de la ligne n1 et de la colonne n3 est identifi par : M[1][3]
On peut alors aussi fabriquer une fonction pour crer des matrices d'une taille dfinie.
Exemple. Pour crer des matrices 23 :
def matrice2x3():
return [[0 for j in range(0,3)] for i in range(0,2)]
A = matrice2x3()
print "A=", A
Rsultat:

A= [[0, 0, 0], [0, 0, 0]]

On peut alors aussi fabriquer une fonction pour crer des matrices d'une taille non dfinie.
Exemple. Pour crer des matrices ij :
def matrice(i,j):
return [[0 for q in range(0,j)] for p in range(0,i)]
A = matrice(3,4)
print "A=", A
Rsultat:

A= [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]