Langage Python

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:

Matrice en Python

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 = [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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))
                            
[1 2 3]

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)

                            
A : [ [1 2 3] [3 4 5] ] 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)
                            
A : [ [0. 0. 0.] [0. 0. 0.] ] 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)
                            
A : [0 1 2 3 4 5] 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)
                            
A : [1. 1.6 2.2 2.8 3.4 4. ]

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)
                            
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
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)
                                
A : [[3, 1, 5], [9, 8, -1], [10, 12, 2]]
B : [[8, -1, 8], [2, 1, 3], [18, 2, 32]]
A * B : [[116, 8, 187], [70, -3, 64], [140, 6, 180]]
Remarque ! * est utilisé pour la multiplication de tableaux (multiplication d'éléments correspondants de deux tableaux) et non de matrices.
                                import numpy as np
    
                                A = np.array([ [3, 1, 5], [10, 12, 2] ])
        
                                C = A*2
    
                                print("A : ", A)
                                print("A * 2 : ", C)
                            
A : [ [ 3 1 5] [10 12 2] ] 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)
                            
A : [[ 3 1 5] [ 9 8 -1] [10 12 2]]
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[0] = 2
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[0][0] = 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[0] = [ 1 4 5 12]
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[:,0] = [ 1 -5 -6]
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[2:5] : [5 7 9]
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[: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]]

Comme vous pouvez le voir, L'utilisation de NumPy (au lieu de listes imbriquées) rend beaucoup plus facile de travailler avec des matrices

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :