Chap3 Listes

Les listes
Le module array
Le module numpy
Les matrices en python
Chapitre 3
Les listes et les matrices
2eme Année API

Texte
Texte
Texte
saadi mo@yahoo.fr
26 octobre 2022
ENSA, Khouribga 2022-2023 1/ 44

Les listes
Le module array
Le module numpy
Plan
1 Les listes
Concepts fondamentaux
Accès aux composantes d’une liste
La fonction range()
Les tranches (slicing)
Fonctions communes sur les listes
Méthodes pour les listes
2 Le module array
3 Le module numpy
4 Les matrices en python

Les listes
Le module array
Le module numpy
Plan
1 Les listes
La fonction range()
2 Le module array
3 Le module numpy

Les listes
Le module array
Le module numpy
Introduction
En python, les types prédéfinis tel que : int, float, bool et str restent limités pour
résoudre des problèmes complexes. A titre d’exemple, nous citons le problème suivant :
comment peut-on modéliser (représenter dans la RAM) des objets comme :
Etudiant(nom,prénom,age,note,...)
Voiture (marque,modèle, prix,couleur,...)
Vecteur(abs, ord)
etc
Pour résoudre ce problème, l’utilisation d’une structure données est désormais
nécessaire.
Qu’est ce qu’une structure de données ?
Une structure de données consiste à utiliser un ensemble de variables pour
modéliser un tel objet.
Python offre une diversité des structures de données comme :
• listes ;
• tuples ;
dictionnaires ;
etc.

Les listes
Le module array
Le module numpy
Définition
Qu’est ce qu’une liste
Une liste une structure de données ordonnées particulièrement souple.
Les listes peuvent contenir toutes sortes de données telles que : entiers, réels,
complexes, caractères, logiques, chaı̂nes de caractères, tuples, tuples,
dictionnaires, ensemble, voire d’autres listes.
Une liste est une collection ordonnée et modifiable : chaque élément est classé
selon un index numérique et peut être librement redéfini.
La numérotation des index commence à partir de zéro.
⇒ Exemple
>>> L = [1, 2, 3]
>>> type(L)
< class ′ list ′ >

Les listes
Le module array
Le module numpy
Déclaration d’une liste

Syntaxe
On peut définir une liste comme une collection d’éléments séparés par des
virgules, l’ensemble étant enfermé dans des crochets
Nom Liste = [Val1 , Val2 , ..., Vali , ..., Valn ]
chaque élément Vali peut avoir n’importe quel type
Exemple :
1 E=[“Sami”,19,10.5], E est une liste qui contient trois types différents :
chaı̂nes de caractères (str), entier (int) et réel (float).
2 L= [2, 100, ”hello”, 1.0],
Liste vide
Pour créer une liste vide il existe deux méthodes :
1 L=list() # cette fonction permet de convertir aussi n’importe quel type de
données en liste
2 L= [],

Les listes
La fonction range()
Le module array
Le module numpy
Un accès partiel
Il existe deux types d’indices pour l’accès partiel à chaque élément d’une liste :
Indiçage positif
Soit la liste suivante : L = [1, −6, 30, 26, 10] contenant n=5 valeurs
l’accès au premier élément de la liste L se fait par L[0] (L[0]=1)
l’accès au dernier élément de la liste se fait par L[n-1] (L[n-1]=10)
les listes sont des séquences modifiables, on peut changer la valeur de chaque
champ L[i]. Par exemple, L[0]=30
.
Indiçage négatif
Il existe un moyen de désigner les éléments d’une séquence en partant de la fin :
L[-1] est le dernier élément de la séquence
L[-2] est l’avant-dernier
Si k > 0, L[-k] vaut L[len(s)-k], avec len retourne le nombre des éléments de L.
.

Les listes
La fonction range()
Le module array
Le module numpy
Un accès total
Exemple 1
Copie superficielle (shallow copy)
>>> L1 = [1, 2, [5, 6, 7]]
L’accès globale à une liste consiste à affecter une >>> L2 = L1; print(L1, L2)
liste L1 à une autre liste L2, L2=L1 [1, 2, [5, 6, 7]][1, 2, [5, 6, 7]]
Mais cette affectation une copie superficielle qui >>> L2[2][0] = 10.5
pose un problème. >>> print(L1, L2)
[1, 2, [10.5, 6, 7]][1, 2, [10.5, 6, 7]]
Le test donné dans l’exemple 1 permet de
comprendre ce qui se passe :
Exemple 2
Copie en profondeur (deep copy)
import copy
Pour obtenir un comportement différent, on >>> L1 = [1, 2, [5, 6, 7]]
dispose d’un module copy qui offre une copie en >>> L2 = copy .deepcopy (a)
profondeur : >>> L2[2][0] = 3.2
L’exemple 2 permet d’illustrer ce mécanisme : >>> print(L1, L2)
[1, 2, [5, 6, 7]][1, 2, [3.2, 6, 7]]

Les listes
La fonction range()
Le module array
Le module numpy
Création d’une liste à l’aide de la fonction range()

Principe de la fonction range()
La fonction range() génère par défaut une séquence de nombres entiers de
valeurs croissantes ou décroissantes.
L’appel de fonction range(n) génère les nombres de 0 à n-1.
L’appel de fonction range(début,fin,pas) génère les nombres de début jusqu’à la
valeur fin-1 et pas la valeur à sauter pour passer d’une valeur à la suivante.
Création d’une liste en utilisant range()

En Python, il existe deux méthodes pour générer les éléments d’une liste en utilisant la
fonction range :
Méthode 1 Méthode 2
>>> L = list(range(10)) >>>L1=[i for i in range(1,10,2)]
>>> print(L) >>> L1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 3, 5, 7, 9]
>>> list(range(5, 13)) >>> [i*i for i in range(10,1,-1)]
[5, 6, 7, 8, 9, 10, 11, 12] [100, 81, 64, 49, 36, 25, 16, 9, 4]

Les listes
La fonction range()
Le module array
Le module numpy
Parcours d’une liste
La boucle for
L’instruction for est l’instruction idéale pour parcourir une liste :
1 Exemple 1 :
>>> L = [1, 2, 5, 6, 7]
>>> for i in range(len(L)) :
... print(L[i],end=”)
12567
2 Exemple 2 :
>>> for n in range(1, 20, 3) :
... print(n, n**2, n**3)
111
4 16 64
7 49 343
10 100 1000
13 169 2197
16 256 4096
19 361 6859

Les listes
La fonction range()
Le module array
Le module numpy

Il arrive fréquemment, lorsque l’on travaille avec des listes, que l’on souhaite extraire
une sous séquence de la liste initiale. Python propose pour cela une technique simple
que l’on appelle slicing (≪ découpage en tranches ≫). Elle consiste à indiquer entre
crochets les indices correspondant au début et à la fin de la ≪ tranche ≫ que l’on
souhaite extraire :
Soit lst une liste quelconque.
lst[p] renvoie l’élément d’indice p de lst. centrale
lst[p :n] renvoie une nouvelle liste constituée des éléments de lst d’indice p
inclus à n exclu.
lst[p :n :pas] renvoie une nouvelle liste constituée des éléments de lst d’indice p
inclus à n exclu, tous les pas.
lst[ :] renvoie une nouvelle liste constituée de tous les éléments de lst.
lst[p :] renvoie une nouvelle liste constituée de tous les éléments de lst à partir
de l’élément d’indice p inclus.
lst[ :n] renvoie une nouvelle liste constituée de tous les éléments de lst depuis le
premier jusqu’à l’élément d’indice n exclu.
lst[ : :pas] renvoie une nouvelle liste constituée des éléments de lst, tous les pas.
.
Les listes
La fonction range()
Le module array
Le module numpy
Insertion/Suppression d’un ou plusieurs éléments

Insertion dans une liste n’importe où
>>> L=[2, 5, 10, 89, 92] ;L
[2, 5, 10, 89, 92]
>>> L[3 :3]=[12,15] ; L
[2, 5, 10, 12, 15, 89, 92]
>>>L=[2, 5, 10, 89, 92]
>>>L[0 :0]=[10,20,30]] ; L
[10, 20, 30, 2, 5, 10, 89, 92]
Suppression/remplacement d’un ou plusieurs éléments

>>> L=[2, 5, 10, 89, 92] ;L
[2, 5, 10, 89, 92]
>>> L[4 :5]=[] ; L
[2, 5, 10, 89]
>>>L[2 :4]=[99] ; L #on utilise la liste initiale L=[2, 5, 10, 89, 92]
[2, 5, 99, 92]

Les listes
La fonction range()
Le module array
Le module numpy

Soit la liste suivante : L=[6,2,7,-10,56,13]
Les fonctions : len, min, max, sum et del
La fonction len() retourne le nombre des éléments d’une liste len(L) = 6
La fonction min() retourne la valeur minimale d’une liste min(L) = −10
La fonction max() retourne la valeur maximale d’une liste max(L) = 56
La fonction sum() retourne la somme des éléments d’une liste sum(L) = 74
La fonction del() permet de supprimer un élément d’une liste del(L[0])
⇒ Exemples :
>>> L=[6,2,7,-10,56,13]
>>>len(L)
6
>>>min(L)
-10
>>>sum(L)
74

Les listes
La fonction range()
Le module array
Le module numpy
Les opérateurs : +, * et in
L1+L2 l’opérateur + permet de concaténer les deux listes L1 et L2.
L*i l’opérateur * permet de retourner une nouvelle liste contenant i copies de L.
x in L : retourne True si x est dans L et False sinon.
⇒ Exemples :
>>>L1=[0,2,4],L2=[1,3,5]
>>>L3=L1+L2
>>>print(L3)
[0, 2, 4, 1, 3, 5]
>>>L4=L1*3
>>>print(L4)
[0, 2, 4, 0, 2, 4, 0, 2, 4]
>>>2 in L1
True
>>>print(L1[5])
IndexError : list index out of range

Les listes
La fonction range()
Le module array
Le module numpy
Méthode Type de retour Déscription

list() list Renvoie une liste vide
L.append(x) None ajoute un élément x (nombre, chaı̂ne, liste, tuple, dic-
tionnaire) à la fin d’une liste
L.insert(i,x) None Modifie L en insérant x dans la position de l’indice i
L.extend(seq) None Modifie L en lui ajoutant les éléments de l’itérable
seq.
L.count(x) int retourne le nombre d’occurrences de x dans la liste L
L.index(x) int retourne l’indice du premier élément de L égale à x
(ValueError si x n’existe pas)
L.index(x,n) int retourne l’indice de la nième occurrence de x dans L
L.pop() item renvoie le dernier élément et le supprime de la liste
L.remove(x) None supprime la première occurrence de x dans L
L.reverse() None Modifie L en renversant l’ordre de ses éléments
L.sort() None Modifie L en triant par ordre croissant ses éléments

Les listes
La fonction range()
Le module array
Le module numpy
Exemples
Ecrire une fonction fibonacci(N) qui prend en argument un entier
N et retourne une liste contenant les N premiers termes de la suite
de Fibonacci : 
1
 si n = 0
Fn = 1 si n = 1

Fn−1 + Fn−2 si n >= 2

Solution
def fibonacci(N) :
Texte result = [0, 1] # Initialisation
Texte for k in range(2, N) :
TexteTexte result.append(result[k-1] + result[k-2])
Texte return result
La définition de la fonction est proche de la défitiontion par récurrence de la suite, la
boucle for jouant le rôle de la relation de récurrence.
>>>fibonacci(16)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

Les listes
La fonction range()
Le module array
Le module numpy
Exemples
Ecrire une fonction listeAleatoire(n) qui prend un entier n en
argument et renvoie une liste de taille n contenant des nombres
entre 1 et 100 tirés au hasard. Vous utiliserez pour ce faire la
fonction randint du module random.
Solution
from random import randint
def listeAleatoire(n) :
Texte L=[] #liste vide
Texte for k in range(1, n+1) :
TexteTexte a=randint(1,100)
TexteTexte L.append(a) #L=L+[a]
Texte return L
La définition de la fonction est proche de la défition par récurrence de la suite, la
boucle for jouant le rôle de la relation de récurrence.
>>>listeAleatoire(10)
[5, 1, 13, 21, 34, 5, 89, 44, 10, 78]]

Les listes
Le module array
Le module numpy
Plan
1 Les listes
La fonction range()
2 Le module array
3 Le module numpy

Les listes
Le module array
Le module numpy
Implémentation avec le module array

Syntaxe
Pour déclarer un tableau en utilisant le module array, il faut tout d’abord charger ce
module dans la mémoire
>>>from array import *
Nom Tab = array (typecode, [initialisateur ]) avec
initialisateur = [Val1 , Val2 , ..., Valn ] ou initialisateur = range(n)
Exemple
>>> T 1 = array (′ i ′ , [−1, 2, 3] # T1 contient 3 valeurs de type entier.
>>> type(T 1) # pour savoir le type de T1
< type ′ array .array ′ >
>>> T 2 = array (′ f ′ , range(10)) # T2 contient dix valeurs de type réel.
.
Remarque
Avec l’utilisation du module array, nous pouvons assurer d’avoir le même type
pour tous les élément d’un tableau.
.

Les listes
Le module array
Le module numpy
Les types possibles pour array

Le tableau suivant énumère les types possibles pour array.
Type Typecode Taille en octet

str ’c’ 1
int ’b’ 1
int ’B’ 1
unicode ’U’ 2
int ’h’ 2
int ’H’ 2
int ’i’ 2
long I 2
int l 4
long ’L’ 4
float ’f’ 4
float ’d’ 8

Les listes
Le module array
Le module numpy
Remplir et afficher un tableau

On applique le même principe que les listes.
Les opérateurs : +,*,-,/ et in

c’est identique que l’implémentation d’un tableau avec une liste.
Les fonctions prédéfinies et originales

c’est identique que l’implémentation d’un tableau avec une liste.

Les listes
Le module array
Le module numpy
Plan
1 Les listes
La fonction range()
2 Le module array
3 Le module numpy

Les listes
Le module array
Le module numpy
Implémentation avec le module numpy

Principe
NumPy est un package pour le calcul scientifique dans Python.
Géneralment ce module n’est pas intégré par défaut dans Python, on peut le
telecharger via ce lien http : //numpy .scipy .org
NumPy se spécialise dans le calcul matriciel, des tableaux multidimensionnels,
l’algèbre linéaire, des fonctions de nombre aléatoire et l’anlyse numérique.
.
Syntaxe
Pour déclarer un tableau en utilisant le module numpy, il faut tout d’abord charger ce
module dans la mémoire
>>>from numpy import *
Nom Tab = array ([initialisateur ], dtype)
Exemple
>>> T 1 = array ([−1, 2, 3], dtype = int) # T1 contient 3 valeurs entières.
>>> T 2 = array (range(10), dtype = float) # T2 contient 10 valeurs réelles.
.
Les listes
Le module array
Le module numpy
Initialisation d’un tableau

Pour initialiser un tableau, il existe deux fonctions dans le module numpy :
1 En utilisant la fonction zeros :
>>> T = zeros(10, dtype = float)
>>>T
array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
2 En utilisant la fonction ones :
>>> T = ones(5, dtype = int)
>>>T
array([ 1, 1, 1, 1, 1])
Remplir et afficher un tableau

On applique le même principe que les listes.

Les listes
Le module array
Le module numpy

Soient T1 et T2 deux tableaux T1 déjà déclarées et remplis respectivement par N1 et
N2 valeurs quelconques (int, float,etc..). On suppose que ces deux tableaux sont
implémentés en utilisant le module numpy.
>>> T 1 = array (range(4), dtype = int); T 2 = array (range(4), dtype = int)
L’opérateur + (respectivement -) permet d’additionner (respectivement
soustraire) les éléments de deux tableaux T1 et T2.
>>> T 1 + T 2
[0, 2, 4, 6]
L’opérateur * (respectivement /) permet multiplier (respectivement diviser)
chaque élément du tableau T1 avec son équivalent en T2.
>>> T 1 ∗ T 2
[0, 1, 4, 9]
T1*i : retourne le produit sclaire de T1 par i.
>>> 3 ∗ T 1 #c’est la même chose que T1*3
[0, 3, 6, 9]
x in T1 : retourne True si x est appartient au tableau T1 et False sinon.
>>> 3 in T1
True
Les listes
Le module array
Le module numpy

Les fonctions originales
La création d’une nouvelle fonction qui utilise le module numoy est identique que
l’implémentation d’un tableau avec une liste.
Les fonctions prédéfinies

Le module numpy intégre de nombreuses fonctions prédéfinies qui permettent
d’effectuer différentes opérations :
det : cette fonction permet de calculer le determinant d’une matrice carrée
inv : cette fonction permet de calculer l’inverse d’une matrice.
solve : cette fonction permet de résoudre une équation d’un système linéaire
eig : cette fonction permet de calculer les valeurs et les vecteurs propres d’une
matrice carrée.
traspose : cette fonction permet de calculer la transposée d’une matrice carrée.
etc.
.

Les listes
Le module array
Le module numpy
Plan
1 Les listes
La fonction range()
2 Le module array
3 Le module numpy

Les listes
Le module array
Le module numpy
Qu’est ce qu’une matrice ?
Une matrice est une liste de listes qui peut être représenté
sous la forme suivante :
La matrice contient n lignes et p colonnes

Chaque ligne de la matrice M représente un tableau à une
seule dimension c-à-d une liste
Exemple : La première ligne de la matrice M est une liste
L0=[a1,1 , a1,2 , ...., a1,p−1 , a1,p ]

Les listes
Le module array
Le module numpy
Implémentation d’une matrice en python
Il existe 2 possibilités pour implémenter (représenter) une matrice

en python :
1 En utilisant les listes :
L = [[a0,0 , ..., a0,p−1 ], [a1,0 , ..., a1,p−1 ], ...[an−1,0 , ..., an−1,p−1 ]]
2 En utilisant le module numpy :
from numpy import *
L=array ([[a0,0 , ..., a0,p−1 ], ..., [an−1,0 , ..., an−1,p−1 ]], dtype =
type)

Les listes
Le module array
Le module numpy
Implémentation avec une liste

Syntaxe
T=[[0]*C for i in range(L)]
• C : indique le nombre de colonnes
• L : indique le nombre de lignes
⇒Exemples
T=[[0]*3 for i in range(2)] A=[[-1,2,3],[6,8,10],[4,-2,0]]
TextText⇕ TextTextText⇕
T=[[0,0,0],[0,0,0]]
 
−1 2 3
TextText⇕
A= 6 8 10
0 0 0 4 −2 0
T =
0 0 0 A est une matrice carrée d’ordre 3
• len(T)=2 #c’est le nombre de lignes
• len(A)=3
Les listes
Le module array
Le module numpy

Soient M1 et M2  deux matrices
 d’ordre
 3 déjà déclarées
 et remplis par des valeurs
1 1 1 2 2 2
entières. M1 = 1 1 1 et M2 = 2 2 2
1 1 1 2 2 2
>>> M1 = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
>>> M2 = [[2, 2, 2], [2, 2, 2], [2, 2, 2]]
L’opérateur + permet de réaliser la concaténations de deux matrices M1 et M2
et non pas la somme matricielle. Cela signifie que
1 1 1
 
 1 1 1
1 1 1
 
M1 + M2 = 
2 2 2

2 2 2
2 2 2
>>> M1 + M2
[[1,1,1],[1,1,1],[1,1,1],[2,2,2],[2,2,2],[2,2,2]]

Les listes
Le module array
Le module numpy

Soient M une matrices d’ordre 2 déjà déclarées et remplis par des valeurs entières.

1 1
M=
1 1
>>> M = [[1, 1], [1, 1]]

M*i : * permet de retourner une matrice contenant i copies de M. Cette
opération ne représente pas le produit scalaire d’une matrice avec un réel.
1 1
 
1 1
1 1
 
3∗M =
1 1

1 1
1 1
>>> 3 ∗ M
[[1,1],[1,1],[1,1],[1,1],[1,1],[1,1]]

Les listes
Le module array
Le module numpy

 
−2 20 3
M =  10 −1 6
1 8 5
>>> M = [[−2, 20, 3], [10, −1, 6], [1, 8, 5]]

x in M : retourne True si x est appartient au tableau M et False sinon.
>>> 3 in M
True
>>> 30 in M
False
Les deux opérateurs - et / n’existent pas.

Les listes
Le module array
Le module numpy

Syntaxe
from numpy import *
T=array([[0]*C for i in range(L)],dtype=type)
• C : indique le nombre de colonnes
• L : indique le nombre de lignes
⇒Exemples
>>>T=array([[0]*3 for i in range(3)]) >>>A=array([[-1,2,3],[6,8,10],[4,-2,0]])
>>>T >>>A
array([[0., 0., 0.], array([[-1, 2, 3],
TextT[0., 0., 0.], TextT[6., 8, 10],
TextT[0., 0., 0.]) TextT[4, -2, 0])
TextText⇕
  TextTextText⇕
 
0 0 0 −1 2 3
T = 0 0 0 A= 6 8 10
0 0 0 4 −2 0

Les listes
Le module array
Le module numpy

⇒Initialisation d’une matrice
Pour initialiser une matrice, il existe deux fonctions dans le module
numpy :
1 En utilisant la fonction zeros :
>>> T = zeros((3, 4), dtype = float)
>>>T
array([[0., 0., 0., 0.],
TextT[0., 0., 0., 0.],
TextT[0., 0., 0., 0.]])
2 En utilisant la fonction ones :
>>> T = ones((5, 3)dtype = int)
>>>T
array([[1., 1., 1.],
TextT[1., 1., 1.],
TextT[1., 1., 1.],
TextT[1., 1., 1.],
TextT[1., 1., 1.]])

Les listes
Le module array
Le module numpy

 d’ordre3 déjà déclarées
 et remplis par des valeurs
1 1 1 2 2 2
entières. M1 = 1 1 1 et M2 = 2 2 2
1 1 1 2 2 2
>>> M1 = array ([[1, 1, 1], [1, 1, 1], [1, 1, 1]], dtype = int)
>>> M2 = array ([[2, 2, 2], [2, 2, 2], [2, 2, 2]], dtype = int)
L’opérateur + (respectivement -) permet de calculer la somme matricielle
(respectivement
 la soustraction)
 de M1 et M2. Cela signifie que :
3 3 3
M1 + M2 = 3 3 3
3 3 3
>>> M1 + M2
array([[3, 3, 3],
TextT[3, 3, 3],
TextT[3, 3, 3])

Les listes
Le module array
Le module numpy

 d’ordre 3 déjà
 déclaréeset remplis par des valeurs
2 −1 3 2 7 −2
entières. M1 = 0 4 1  et M2 = 3 4 0 
1 5 10 6 4 2
>>> M1 = array ([[2, −1, 3], [0, 4, 1], [1, 5, 10]], dtype = int)
>>> M2 = array ([[2, 7, −2], [3, 4, 0], [6, 4, 2]], dtype = int)
L’opérateur * permet d’effectuer la multiplication entre M1 et M2 terme à
terme. Donc il ne représentepas le produit matricile de M1 et M2.
4 −7 −6
M1 ∗ M2 = 0 16 0 
6 20 20
L’opérateur / se fait de la même façon que la multiplication *
>>> M1 ∗ M2
array([[4, -7, -6],
TextT[0, 16, 0],
TextT[6, 20, 20])

Les listes
Le module array
Le module numpy

Soient M une matrices contenant 2 lignes et 3 colonnes, déjà déclarées et remplis par
des valeurs entières.
1 2 3
M=
4 5 6
>>> M = array ([[1, 2, 3], [4, 5, 6]])

M*α : cette opération représente le produit scalaire de M avec un réel α.

3 6 9
3∗M =
12 15 18
>>> 3 ∗ M
array([[3, 6, 9],
TextT[12, 15, 18])

Les listes
Le module array
Le module numpy

 
−2 20 3
M =  10 −1 6
1 8 5
>>> M = array ([[−2, 20, 3], [10, −1, 6], [1, 8, 5]])
x in M : retourne True si x est appartient au tableau M et False sinon.
>>> 3 in M
True
>>> 30 in M
False

Les listes
Le module array
Le module numpy
Accès aux composantes

Soit M une matrice de L lignes et C colonnes d’un type donné(entier, réel,
caractère,etc..).
Pour accéder à n’importe quel élément de la matrice M, on utilise deux indices i
et j.
• L’indice i est utilisé pour parcourir les lignes,
• l’indice j est utilisé pour parcourir les colonnes.
⇒Exemple :
 
1 2 3 4
M= 5  6 7 8
9 10 11 12
TextTextText⇕
>>>M=array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
>>>M[0][0]
-1
>>>M[1][3]
8
>>>M[0]
[1, 2, 3, 4]
>>>M[-1][-1] #On peut uitliser indiçage négatif
12
Les listes
Le module array
Le module numpy
Remplir une matrice

⇒Solution 1 :
La fonction SaisirMat() permet de remplir une matrice contenant
L lignes et C colonnes. Cette fonction retourne une matrice.
Définition de la fonction SaisirMat()
def SaisirMat(L,C) :
#L : nombre de lignes et C : nombre de colonnes
M=[[0] for i in range(C) for i in range(L)]
for i in range(L) :
for i in range(C) :
print(”T[”,i,”][”,j,”]=”,end=””)
T[i]=int(input())
return M
⇒Exemple :
NL=int(input(”Donnez le nombre de lignes :”))
NC=int(input(”Donnez le nombre de colonnes :”))
#Appel
M=SaisirMat(NL,NC)
Les listes
Le module array
Le module numpy
Remplir une matrice

⇒Solution 2 :
La fonction SaisirMat(M) permet de remplir une matrice carrée
M d’ordre len(M).

def SaisirMat(M) :
for i in range(len(M)) :
print(”T[”,i,”][”,j,”]=”,end=””)
T[i]=int(input())
return M
⇒Exemple :
N=int(input(”Donnez l’ordre de la matrice :”))
M=[[0] for i in range(N) for i in range(N)]
#Appel
SaisirMat(M)

Les listes
Le module array
Le module numpy
Afficher les éléments d’une matrice

⇒Solution 1 : La fonction AfficherMat(M) permet d’afficher les éléments d’une
matrice M de L lignes et C colonnes.

def AfficherMat(M,L,C) :
for i in range(L) :
for i in range(C) :
print(T[i][j]=,end=” ”)
print(” ”)
⇒Exemple :
 
1 1 1 1 1
M = 2 2 2 2 2

3 3 3 3 3
TextTextText⇕
>>>M=array([[1,1,1,1,1],[2,2,2,2,2],[3,3,3,3,3]])
>>>AfficherMat(M,len(M),len(M[0]))
11111
22222
33333
Les listes
Le module array
Le module numpy
Afficher les éléments d’une matrice

⇒Solution 2 : La fonction AfficherMat(M) permet d’afficher les éléments d’une
matrice carrée M d’ordre len(M).

def AfficherMat(M) :
print(T[i][j]=,end=” ”)
print(” ”)
⇒Exemple :
 
1 2 3
M = 4 5 6

7 8 9
TextTextText⇕
>>>M=array([[1,2,3],[4,5,6],[7,8,9]])
>>>AfficherMat(M)
123
456
789
Les listes
Le module array
Le module numpy
Le module numpy :matrix()

On peut aussi définir une matrice à partir d’une liste ou d’une chaı̂ne de
caractère qui comprenne la multiplication matricielle, grâce à matrix() :
>>> from numpy import *
>>> A = matrix([[1,1,1],[0,1,1],[0,0,1]])
>>> A
matrix([[1, 1, 1],
TextT[0, 1, 1],
TextT[0, 0, 1]])
>>> B = matrix(’1 2 3 ; 2 3 4 ; 4 5 6’)
>>> B
matrix([[1, 2, 3],
TextT[2, 3, 4],
TextT[4, 5, 6]])
>>> A * B #Le produit matriciel est correct
matrix([[7, 3, 10],
TextT[6, 8, 10],
TextT[4, 5, 6]])
>>> A ** -1 # L’inversion aussi est correct
matrix([[1., -1., 0.],
TextT[0., 1., -1.],
TextT[0., 0., 1.]])
Les listes
Le module array
Le module numpy
Les fonctions prédéfinies

Le module numpy contient des fonctions mathématiques usuelles s’appliquant à un
scalaire ou à un tableau de scalaires.

Les listes
Le module array
Le module numpy
Le sous module numpy.linalg

Dans Python, la bibliothèque numpy.linalg contient lafonction solve qui joue le
même rôle que la fonction gauss que nous venons décrire.
Pour l’utiliser, il suffit de charger la bibliothèque, puis d’appliquer la fonction
solve en précisant les deux paramètres A et b.
L’exemple ci-dessous va nous permettre de tester la fonction solve pour résoudre
le même système :
     
2 4 −4 1 x1 0
 3
 6 1 −2 ∗ x2  = −7
   
−1 1 2 3  x3   4 
1 1 −4 1 x4 2
⇒Code python
>>>from numpy import linalg,array
>>>A = array([[2, 4,-4,1],[3, 6, 1,-2],[-1, 1, 2,3],[1,1,-4,1]],dtype=float)
>>>b = array([[0], [-7], [4],[2]], dtype=float)
>>> solve(A, b)
array([ 1., -1., -0., 2.])

Les listes
Le module array
Le module numpy
Le sous module numpy.linalg

Le module numpy.linalg contient en outre une fonction det pour calculer le
déterminant ainsi qu’une fonction inv pour calculer l’inverse :
L’exemple ci-dessous va nous permettre de tester les deux fonctions det et inv
 
2 4 −4 1
 3 6 1 −2
A=
−1

1 2 3 
1 1 −4 1
⇒Code python
>>>from numpy import *
>>>A = array([[2, 4,-4,1],[3, 6, 1,-2],[-1, 1, 2,3],[1,1,-4,1]],dtype=float)
>>>linalg.det(A)
-28.000000000000021
>>>linalg.inv(A)
array([[-3.5 , 1.5 , 0.75 , 4.25 ],
TextT[ 1.5 , -0.5 , -0.25 , -1.75 ],
TextT[-0.78571429, 0.35714286, 0.25 , 0.75 ],
TextT[-1.14285714, 0.42857143, 0.5 , 1.5 ]])

Chap3 Listes

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap3 Listes

Transféré par

Droits d'auteur :

Formats disponibles

Les listes

2eme Année API

ENSA, Khouribga 2022-2023 1/ 44

4 Les matrices en python

ENSA, Khouribga 2022-2023 2/ 44

4 Les matrices en python

ENSA, Khouribga 2022-2023 3/ 44

ENSA, Khouribga 2022-2023 4/ 44

ENSA, Khouribga 2022-2023 5/ 44

Déclaration d’une liste

ENSA, Khouribga 2022-2023 6/ 44

ENSA, Khouribga 2022-2023 7/ 44

ENSA, Khouribga 2022-2023 8/ 44

Création d’une liste à l’aide de la fonction range()

Création d’une liste en utilisant range()

ENSA, Khouribga 2022-2023 9/ 44

Parcours d’une liste

ENSA, Khouribga 2022-2023 10/ 44

Les tranches (slicing)

Insertion/Suppression d’un ou plusieurs éléments

Suppression/remplacement d’un ou plusieurs éléments

ENSA, Khouribga 2022-2023 12/ 44

Fonctions communes sur les listes

ENSA, Khouribga 2022-2023 13/ 44

Fonctions communes sur les listes

ENSA, Khouribga 2022-2023 14/ 44

Méthodes pour les listes

Méthode Type de retour Déscription

ENSA, Khouribga 2022-2023 15/ 44

ENSA, Khouribga 2022-2023 16/ 44

ENSA, Khouribga 2022-2023 17/ 44

4 Les matrices en python

ENSA, Khouribga 2022-2023 18/ 44

Implémentation avec le module array

ENSA, Khouribga 2022-2023 19/ 44

Implémentation avec le module array

Les types possibles pour array

Type Typecode Taille en octet

ENSA, Khouribga 2022-2023 20/ 44

Implémentation avec le module array

Remplir et afficher un tableau

Les opérateurs : +,*,-,/ et in

Les fonctions prédéfinies et originales

ENSA, Khouribga 2022-2023 21/ 44

4 Les matrices en python

ENSA, Khouribga 2022-2023 22/ 44

Implémentation avec le module numpy

Implémentation avec le module numpy

Initialisation d’un tableau

Remplir et afficher un tableau

ENSA, Khouribga 2022-2023 24/ 44

Implémentation avec le module numpy

Implémentation avec le module numpy

Les fonctions prédéfinies

ENSA, Khouribga 2022-2023 26/ 44

4 Les matrices en python

ENSA, Khouribga 2022-2023 27/ 44

Qu’est ce qu’une matrice ?

La matrice contient n lignes et p colonnes

ENSA, Khouribga 2022-2023 28/ 44

Implémentation d’une matrice en python

Il existe 2 possibilités pour implémenter (représenter) une matrice

ENSA, Khouribga 2022-2023 29/ 44