Les 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. Par exemple:
Cette matrice est une matrice 3x3 car elle comporte 3 lignes et 3 colonnes.
Matrice en Python
Python n'a pas de type intégré pour les matrices. Cependant, nous pouvons traiter une liste de liste comme une matrice. Par exemple:
Exemple 1 :
M = [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
Liste imbriquée
Voyons comment travailler avec une liste imbriquée.
Exemple 2 :
M = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
print("M =", M)
print("M[1] =", M[1]) # 2ème ligne
print("M[1][2] =", M[1][2]) # 3ème élément de la 2ème ligne
print("A[0][-1] =", M[0][-1]) # dernier élément de 1ère ligne
col3 = []; # liste vide
for ligne in M:
col3.append(ligne[2]) # ajouter le 3ème élément
print("col3 : ",col3)
M[1] = [9, 8, -1]
M[1][2] = -1
A[0][-1] = 5
col3 : [5, -1, 2
Ajouter deux matrices
Méthode 1 :
A = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
B = [ [8, -1, 8], [2, 1, 3], [18, 2, 32] ]
n=len(A) # nombre de lignes
m=len(A[0]) # nombre de colonnes
C = [[0]*m for i in range(n)] # matrice de b lignes et m colonnes
# parcourir les lignes
for i in range(n):
# parcourir les colonnes
for j in range(m):
C[i][j]= A[i][j] + B[i][j]
print("A : ", A)
print("B : ", B)
print("A + B : ", C)
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A + B : [[11, 0, 13], [11, 9, 2], [28, 14, 34]]
Dans ce programme, nous avons utilisé des boucles for imbriquées pour parcourir chaque ligne et chaque colonne. A chaque point, nous ajoutons les éléments correspondants dans les deux matrices et les stockons dans C.
Méthode 2 :
A = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
B = [ [8, -1, 8], [2, 1, 3], [18, 2, 32] ]
n=len(A) # nombre de lignes
m=len(A[0]) # nombre de colonnes
C = [[A[i][j] + B[i][j] for j in range(m)] for i in range(n)]
print("A : ", A)
print("B : ", B)
print("A + B : ", C)
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A + B : [[11, 0, 13], [11, 9, 2], [28, 14, 34]]
Transposée d'un matrice
Méthode 1 :
A = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
n=len(A) # nombre de lignes
m=len(A[0]) # nombre de colonnes
C = [[0]*m for i in range(n)] # matrice de b lignes et m colonnes
# parcourir les lignes
for i in range(n):
# parcourir les colonnes
for j in range(m):
C[j][i]= A[i][j]
print("A : ", A)
print("Transposée de A : ", C)
Transposée de A : [[3, 9, 10], [1, 8, 12], [5, -1, 2]]
Méthode 2 :
A = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
B = [ [8, -1, 8], [2, 1, 3], [18, 2, 32] ]
n=len(A) # nombre de lignes
m=len(A[0]) # nombre de colonnes
C = [[A[j][i] for j in range(n)] for i in range(m)]
print("A : ", A)
print("Transposée de A : ", C)
Transposée de A : [[3, 9, 10], [1, 8, 12], [5, -1, 2]]
Multiplier deux matrices
A = [ [3, 1, 5], [9, 8, -1], [10, 12, 2] ]
B = [ [8, -1, 8], [2, 1, 3], [18, 2, 32] ]
n=len(A) # nombre de lignes de A
m=len(B[0]) # nombre de colonnes de B
p=len(B) # nombre de lignes de B
C = [[0]*m for i in range(n)] # matrice de n lignes et m colonnes
# parcourir les lignes de A
for i in range(n):
# parcourir les colonnes de B
for j in range(m):
# parcourir les lignes de B
for k in range(p):
C[i][j] += A[i][k] * B[k][j]
print("A : ", A)
print("B : ", B)
print("A * B : ", C)
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A * B : [[116, 8, 187], [70, -3, 64], [140, 6, 180]]
L'utilisation de listes imbriquées en tant que matrice fonctionne pour des tâches de calcul simples. Cependant, il existe un meilleur moyen de travailler avec des matrices en Python à l'aide de la bibliothéque NumPy.
Tableaux NumPy
NumPy est un package pour le calcul scientifique qui prend en charge un puissant objet tableau à N dimensions. Avant de pouvoir utiliser NumPy, vous devez l’installer.
NumPy fournit un tableau multidimensionnel de nombres (qui est en fait un objet). Prenons un exemple:
Exemple 3 :
import numpy as np
a = np.array([1, 2, 3])
print(a)
print(type(a))
Comme vous pouvez le constater, la classe de tableaux de NumPy s'appelle ndarray.
Comment créer un tableau NumPy ?
Il existe plusieurs façons de créer des tableaux NumPy.
Tableau d'entiers, réels et nombres complexes
Exemple 4 :
import numpy as np
A = np.array([[1, 2, 3], [3, 4, 5]]) # tableau d'entiers
print("A : " , A)
B = np.array([[1.1, 2, 3], [3, 4, 5]]) # tableau des réels
print("B : ", B)
C = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Tableau de nombres complexes
print("C : ", C)
B : [ [1.1 2. 3. ] [3. 4. 5. ] ]
C : [ [1.+0.j 2.+0.j 3.+0.j] [3.+0.j 4.+0.j 5.+0.j] ]
Tableau de zéros et de uns
Exemple 5 :
import numpy as np
A = np.zeros( (2, 3) ) # tableau de zéros
print("A : " , A)
B = np.ones( (4, 2) )# tableau des réels
print("B : ", B)
B : [ [1. 1.] [1. 1.] [1. 1.] [1. 1.] ]
Utiliser arange() et shape()
Exemple 6 :
import numpy as np
A = np.arange(6)
print("A : " , A)
B = A.reshape(2, 6)
print("B : ", B)
B : [ [0 1 2] [3 4 5] ]
Utiliser linspace() : linspace() va créer des tableaux avec un nombre spécifié d’éléments et espacés de manière égale entre les valeurs de début et de fin spécifiées. Par exemple:
Exemple7 :
import numpy as np
A=np.linspace(1., 4., 6)
print("A : ", A)
Opérations sur les matrices
Ci-dessus, nous vous avons donné 3 exemples: ajout de deux matrices, multiplication de deux matrices et transposée d’une matrice. Nous avons utilisé des listes imbriquées pour écrire ces programmes. Voyons comment nous pouvons faire la même tâche en utilisant le tableau NumPy.
Ajout de deux matrices
Nous utilisons l'opérateur + pour ajouter les éléments correspondants de deux matrices NumPy.
Exemple 8 :
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] ])
C= A + B
print("A : ", A)
print("B : ", B)
print("A + B : ", C)
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A + B : [[11, 0, 13], [11, 9, 2], [28, 14, 34]]
Multiplier deux matrices
Pour multiplier deux matrices, nous utilisons la méthode dot().
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] ])
C = A.dot(B)
print("A : ", A)
print("B : ", B)
print("A * B : ", C)
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A * B : [[116, 8, 187], [70, -3, 64], [140, 6, 180]]
import numpy as np
A = np.array([ [3, 1, 5], [10, 12, 2] ])
C = A*2
print("A : ", A)
print("A * 2 : ", C)
A * 2 : [ [ 6 2 10] [20 24 4] ]
Transposée d'une matrice
Nous utilisons la méthode transpose() pour calculer la transposition d’une matrice.
import numpy as np
A = np.array([ [3, 1, 5], [9, 8, -1], [10, 12, 2] ])
C = A.transpose()
print("A : ", A)
print("Transposée de A : ", C)
Transposée de A : [[ 3 9 10] [ 1 8 12] [ 5 -1 2]]
Accéder aux éléments de la matrice, aux lignes et aux colonnes
Accéder aux éléments de la matrice
Comme pour les listes, nous pouvons accéder aux éléments de la matrice à l’aide d’indice. Commençons par un tableau NumPy à une dimension.
Exemple 9 :
import numpy as np
A = np.array([2, 4, 6, 8, 10])
print("A[0] =", A[0]) # 1èr élément
print("A[2] =", A[2]) # 3ème élément
print("A[-1] =", A[-1]) # dernier élément
A[2] = 6
A[-1] = 10
Voyons maintenant comment accéder aux éléments d’un tableau à deux dimensions (matrice).
Exemple 10 :
import numpy as np
A = np.array([[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]])
# Premier élément de la première ligne
print("A[0][0] =", A[0][0])
# Troisième élément de la deuxième ligne
print("A[1][2] =", A[1][2])
# Dernier élément de la dernière ligne
print("A[-1][-1] =", A[-1][-1])
A[1][2] = 9
A[-1][-1] = 19
Accéder aux lignes d'une matrice
Exemple 11 :
import numpy as np
A = np.array([ [1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19] ])
print("A[0] =", A[0]) # Première ligne
print("A[2] =", A[2]) # Troisième ligne
print("A[-1] =", A[-1]) # Dernière ligne
A[2] = [-6 7 11 19]
A[-1] = [-6 7 11 19]
Accéder aux colonnes d'une matrice
Exemple 12 :
import numpy as np
A = np.array([ [1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19] ])
print("A[:,0] =",A[:,0]) # Première colonne
print("A[:,2] =", A[:,2]) # Troisième colonne
print("A[:,-1] =", A[:,-1]) # Dernière colonne
A[:,2] = [ 5 9 11]
A[:,-1] = [12 0 19]
Découpage d'une matrice
Le découpage d'un tableau NumPy à une dimension est similaire à une liste.
Exemple 14 :
import numpy as np
A = np.array([1, 3, 5, 7, 9, 7, 5])
# 3ème à 5ème éléments
print("A[2:5] : ", A[2:5])
# 1er au 4ème élément
print("A[:-5] : ", A[:-5])
# 6ème au dernier élément
print("A[5:] : ", A[5:])
# 1er au dernier élément
print("A[:] : ", A[:])
# inverser une liste
print("A[::-1] : ", A[::-1])
A[:-5] : [1 3]
A[5:] : [7 5]
A[:] : [1 3 5 7 9 7 5]
A[::-1] : [5 7 9 7 5 3 1]
Voyons maintenant comment découper une matrice.
Exemple 15 :
import numpy as np
A = np.array([[1, 4, 5, 12, 14], [-5, 8, 9, 0, 17],[-6, 7, 11, 19, 21]])
print("A[:2, :4] : ", A[:2, :4]) # deux lignes, quatre colonnes
print("A[:1,] : ", A[:1,]) # première ligne, toutes les colonnes
print("A[:,2] : ", A[:,2]) # toutes les lignes, deuxième colonne
print("A[:, 2:5] : ", A[:, 2:5]) # toutes les lignes, troisième à cinquième colonne
A[:1,] : [[ 1 4 5 12 14]]
A[:,2] : [ 5 9 11]
A[:, 2:5] : [[ 5 12 14][ 9 0 17] [11 19 21]]
Comme vous pouvez le voir, L'utilisation de NumPy (au lieu de listes imbriquées) rend beaucoup plus facile de travailler avec des matrices
