Listes#

Jusqu’à présent, chaque variable ne contenait qu’une seule valeur: un chiffre, une valeur booléenne, une chaîne de caractères,… Une liste est une structure de donnéees qui permet de contenir plusieurs variables, soit un ensemble de valeurs.

Créer une liste#

Pour définir une liste dans Python, nous utilisons les crochets ([]). Chaque élément est séparé par une virgule.

Nous allons créer une liste a qui contient les chiffres de 1 à 5 et puis l’afficher.

a = [1, 2, 3, 4, 5]
print(a)

[1, 2, 3, 4, 5]

Les valeurs au sein de la liste ne doivent pas nécessairement être du même type (int, float, bool, …).

Nous allons définir et afficher une liste a qui contient les valeurs a, 1, True, et 2.

a = ['a', 1, True, 2]
print(a)

['a', 1, True, 2]

Tout comme les entiers sont de types int et les nombres décimaux sont de type float, les listes sont de type list.

print(type(a))

<class 'list'>

Les indices#

Chaque élément d’une liste possède un indice (index) qui renseigne sa position dans la liste. Le premier indice est l’indice 0. Le dernier indice est \(n-1\) si \(n\) est le nombre d’éléments dans la liste. Pour accéder à un élément particulier de la liste, il faut indiquer le nom de la liste, suivi de la position de cet élément entre crochets.

  • Définir une liste a qui contient les chiffres 6, 4, 1, 3, et 2.

  • Afficher le premier élément (position 0)

  • Afficher le troisième élément (position 2)

  • Afficher l’élément en position 5

a = [6, 4, 1, 3, 2]
print(a[0]) 
print(a[2]) 
print(a[5]) 

6
1

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Input In [17], in <cell line: 4>()
      2 print(a[0]) 
      3 print(a[2]) 
----> 4 print(a[5])

IndexError: list index out of range

La dernière instruction génère une erreur. En effet, il n’y aucun élément en position 5. On essaie donc d’accéder à un élément en dehors de la liste. Cette erreur causera l’arrêt du programme.

On peut également accéder aux éléments en se référant à la position par rapport à la fin de la liste. Ainsi, le dernier élément aura la position -1, l’avant-dernier élément la position -2, etc.

a = [1, 2, 3, 4, 5]
print(a[-1])    
print(a[-2])    

5
4

Longueur d’une liste#

Pour connaître la longueur d’une liste, nous pouvons utiliser la fonction len.

a = [1, 2, 3, 4, 5]
print(len(a))

5

Sous-ensemble d’une liste#

Pour accéder à plusieurs éléments consécutifs au sein d’une liste, on utilisera le nom de la liste, suivi de crochets et on spécifie les indices de début et de fin. Pour rappel, les éléments seront affichés entre le premier indice inclus et le deuxième indice exclus.

print(a[1:4])

[2, 3, 4]

Si un troisième chiffre est mentionné, ce sera l’incrément. Le code ci-dessous affiche donc les éléments entre la position 0 (incluse) et la position 5 (exclue), par incrément de 2, soit les éléments aux positions 0, 2, et 4.

print(a[0:5:2])

[1, 3, 5]

Générer des listes rapidement#

A l’aide de range et list, il est possible de générer rapidement des listes de taille potentiellement plus importante. range possède un comportement différent en fonction du nombre d’arguments qui sont fournis:

  • 1 argument \(a\) : de 0 (inclus) à \(a\) (non-inclus)

  • 2 arguments \(a\) et \(b\) : de \(a\) (inclus) à \(b\) (non-inclus)

  • 3 arguments \(a\), \(b\), et \(c\): de \(a\) (inclus) à \(b\) (non-inclus) par incrément de \(c\)

  • 1 argument: list(range(a)) produit une liste de 0 à \(a\) (non-inclus)

a1 = list(range(20))
print(a1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

  • 2 arguments: list(range(a, b)) produit une liste de \(a\) (inclus) à \(b\) (non-inclus).

a2 = list(range(10, 15))
print(a2)

[10, 11, 12, 13, 14]

  • 3 arguments: list(range(a, b, c)) produit une liste de \(a\) (inclus) à \(b\) (non-inclus) par pas de \(c\).

a3 = list(range(10, 20, 2))
print(a3)   

[10, 12, 14, 16, 18]

Tester l’appartenance#

Pour savoir si un élément se trouve dans une liste, nous pouvons effectuer un test à l’aide de in. Par exemple, nous avons une liste qui contient des prénoms et nous souhaitons tester si un prénom se trouve dans la liste.

a = ['Christophe', 'Alain', 'Diane', 'Donatien', 'Sandra', 'Thierry']

print('Christophe' in a)    
print('Dianne' in a)        

True
False

Les listes à 2 dimensions#

De nombreux problèmes mathématiques nécessitent de travailler avec des matrices, c’est-à-dire des tableaux à deux dimensions contenant des valeurs. Nous pouvons encoder une matrice en créant une liste de listes. Supposons que nous souhaitions créer une matrice de 3 lignes et 3 colonnes contenant les chiffres de 1 à 9, nous allons créer une liste contenant elle-même 3 listes:

1

2

3

4

5

6

7

8

9

 
m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(m)

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Nous pouvons accéder à chaque sous-liste de manière séparée.

m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("1ere sous-liste:", m[0])
print("2eme sous-liste:", m[1])
print("3eme sous-liste:", m[2])

1ere sous-liste: [1, 2, 3]
2eme sous-liste: [4, 5, 6]
3eme sous-liste: [7, 8, 9]

L’élément 0 de la liste m est une liste. Si nous souhaitons accéder à des chiffres particuliers:

m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(m[0][1])  
print(m[1][1])  
print(m[3][3])  

2
5

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Input In [12], in <cell line: 4>()
      2 print(m[0][1])  
      3 print(m[1][1])  
----> 4 print(m[3][3])

IndexError: list index out of range

Le troisième print génère une erreur car il n’y a pas de liste en position 3.

Nous pouvons finalement afficher les chiffres tels que présentés dans le tableau.

print(m[0][0], m[0][1], m[0][2])
print(m[1][0], m[1][1], m[1][2])
print(m[2][0], m[2][1], m[2][2])

1 2 3
4 5 6
7 8 9

Les méthodes sur listes#

Il existe quelques méthodes qui permettent de modifier une liste, et notamment le fait d’ajouter un ou plusieurs éléments à une liste, potentiellement à une place bien déterminée.

Ajouter un élement à une liste#

La méthode append permet d’ajouter un élément à la fin de la liste. Nous commençons par définir une liste qui contient 5 chiffres. Nous affichons cette liste et nous affichons également sa longueur. Ensuite, nous utilisons la méthode append pour ajouter le chiffre 0 à la fin de la liste. Nous réaffichons la liste pour montrer que le changement a bien eu lieu, et que la longueur de la liste a augmenté de 1. Ensuite, nous ajoutons une liste qui contient 2 chiffres, 9 et 5. Dans ce cas, c’est bien la liste qui est ajoutée. On remarque que la longueur de la liste n’a augmenté que de 1 à nouveau, même si on a ajouté une liste qui contient 2 chiffres.

a = [1, 2, 4, 6, 3]
print(a)
print("Longueur de la liste:", len(a))
a.append(0)
print(a)
print("Longueur de la liste:", len(a))
a.append([9, 5])
print(a)
print("Longueur de la liste:", len(a))

[1, 2, 4, 6, 3]
Longueur de la liste: 5
[1, 2, 4, 6, 3, 0]
Longueur de la liste: 6
[1, 2, 4, 6, 3, 0, [9, 5]]
Longueur de la liste: 7

Ajouter plusieurs éléments#

Nous avons vu dans la section précédente que la méthode append ne permet pas d’ajouter plusieurs chiffres simultanément. La méthode extend permet de le faire. Nous repartons de la même liste initiale. A l’aide de la méthode extend, le nombre d’éléments de la liste passe de 5 à 7.

a = [1, 2, 4, 6, 3]
print(a)
print("Longueur de la liste:", len(a))
a.extend([9, 5])
print(a)
print("Longueur de la liste:", len(a))

[1, 2, 4, 6, 3]
Longueur de la liste: 5
[1, 2, 4, 6, 3, 9, 5]
Longueur de la liste: 7

Ajouter un élément à une place spécifique#

Jusqu’à présent, nous avons ajouté un ou plusieurs chiffres à la fin de la liste. Si nous souhaitons les insérer à une place particulière au sein de la liste, nous pouvons utiliser la méthode insert. Dans ce cas, il faut spécifier 2 informations: (1) la place à laquelle nous souhaitons insérer le chiffre, et (2) le chiffre en question. Dans l’exemple ci-dessous, nous insérons le chiffre 6 à la position 2 (et pas le chiffre 2 à la position 6).

a = [1, 2, 3, 4, 5]
print(a)
a.insert(2, 6)
print(a)

[1, 2, 3, 4, 5]
[1, 2, 6, 3, 4, 5]

Supprimer un élément#

Pour supprimer un élément d’une liste, nous devons utiliser la méthode remove. Si la liste contient plusieurs fois le chiffre à supprimer, cette méthode ne supprime que la première occurence rencontrée. Dans l’exemple ci-dessous, la liste a contient 2 fois le chiffre 3. Seul le premier a été supprimé.

a = [1, 3, 5, 2, 5, 3, 0, 4]
print(a)
a.remove(2)
print(a)
a.remove(3) 
print(a)

[1, 3, 5, 2, 5, 3, 0, 4]
[1, 3, 5, 5, 3, 0, 4]
[1, 5, 5, 3, 0, 4]

Supprimer une liste#

Avec la méthode clear, il est possible de supprimer le contenu d’une liste. Cependant la liste existe toujours, bien qu’elle sera vide.

del permet de supprimer la référence à la liste, ce qui implique qu’elle n’existe plus.

a = [1, 2, 4, 6, 3]
print("Adresse memoire", hex(id(a)))
print(a)

# on efface le contenu mais on ne la supprime pas
a.clear()
print("Adresse memoire", hex(id(a)))
print(a)

# suppression de la liste
del a
print("Adresse memoire", hex(id(a))) 

Adresse memoire 0x7fc868698b40
[1, 2, 4, 6, 3]
Adresse memoire 0x7fc868698b40
[]

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [15], in <cell line: 12>()
     10 # suppression de la liste
     11 del a
---> 12 print("Adresse memoire", hex(id(a)))

NameError: name 'a' is not defined

Trier une liste#

La méthode sort permet de trier une liste. Par défault, cette méthode trie la liste dans l’ordre croissant. Pour trier une liste dans l’ordre décroissant, il faut spécifier reverse=True.

a = [1, 3, 5, 2, 5, 3, 0, 4]
print(a)

# tri et affichage de la liste
a.sort()
print(a)

[1, 3, 5, 2, 5, 3, 0, 4]
[0, 1, 2, 3, 3, 4, 5, 5]

# tri decroissant 
a.sort(reverse=True)
print(a)

[5, 5, 4, 3, 3, 2, 1, 0]

Inverser une liste#

reverse permet d’inverser une liste. Le premier élément devient le dernier et inversément, le deuxième devient avant-dernier, et ainsi de suite. Il ne s’agit donc pas d’un tri !

a = [1, 3, 5, 2, 5, 3, 0, 4]
print(a)
a.reverse()
print(a)

[1, 3, 5, 2, 5, 3, 0, 4]
[4, 0, 3, 5, 2, 5, 3, 1]

Compter le nombre d’éléments dans une liste#

count permet de compter le nombre d’occurences d’un élément dans une liste.

La liste a contient 3 fois le chiffre 2.

a = [1, 2, 4, 6, 3, 2, 4, 2]
print(a)
print("Nb chiffre 2 : ", a.count(2))

[1, 2, 4, 6, 3, 2, 4, 2]
Nb chiffre 2 :  3

Trouver la position d’un élément dans une liste#

index renvoie l’indice à laquelle se trouve un élément dans une liste si cet élément fait effectivement partie de la liste, et renvoie une erreur si cet élément ne fait pas partie de la liste.

profs = ['Christophe', 'Alain', 'Diane', 'Donatien', 'Sandra', 'Thierry']

print(profs.index('Christophe'))    
print(profs.index('Diane'))         
print(profs.index('Dianne'))        

0
2

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [16], in <cell line: 5>()
      3 print(profs.index('Christophe'))    
      4 print(profs.index('Diane'))         
----> 5 print(profs.index('Dianne'))

ValueError: 'Dianne' is not in list

Supprimer un élément d’une liste sur base de sa position#

pop permet de supprimer un élément à une position spécifique dans une liste. Si aucun argument n’est mentionné, c’est le dernier élément de la liste qui est supprimé.

a = [1, 3, 5, 2, 5, 3, 0, 4]
print(a)
a.pop(3)     # supprime le chiffre 2 (indice=3)
print(a)
a.pop()      # supprime le chiffre 4 (dernier element)
print(a)

[1, 3, 5, 2, 5, 3, 0, 4]
[1, 3, 5, 5, 3, 0, 4]
[1, 3, 5, 5, 3, 0]

Copier une liste#

Supposons qu’une liste soit stockée dans la variable a. Si on souhaite copier le contenu de cette variable a dans une autre variable, b, on pourrait simplement écrire b = a. En affichant les 2 variables, on constate que le contenu des 2 variables est semblable.

a = [1, 2, 3, 4]
b = a 
print(a)
print(b)

[1, 2, 3, 4]
[1, 2, 3, 4]

Cependant, si on modifie la variable a, par exemple, en ajoutant un chiffre à l’aide de la méthode append, on constate que la variable b est également affectée.

a.append(5)
print(a)
print(b)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

La raison est que le signe d’égalité utilisé plus haut a fait en sorte que les 2 variables a et b pointent vers le même objet. On peut d’ailleurs s’en convaincre en affichant l’adresse mémoire de cette liste. Le schéma ci-dessous illustre le fait que les 2 variables pointent vers la même liste.

print(hex(id(a)))
print(hex(id(b)))

0x7fb5f0b8ec00
0x7fb5f0b8ec00

La méthode copy permet d’effectuer une copie de la liste a et de la stocker dans la variable b. Ceci crée une 2ème liste qui est indépendante de la première liste. Une modification de a n’affecte donc pas b.

a = [1, 2, 3, 4]
b = a.copy()       # permet de creer une autre liste
print(a)
print(b)
a.append(5)
print(a)
print(b)
print(hex(id(a)))
print(hex(id(b)))

[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4]
0x7fb5a0034a80
0x7fb5a00349c0

De manière similaire, b = a[:] permet d’atteindre le même résultat.

a = [1, 2, 3, 4]
b = a[:] # permet de faire une copie
print(a)
print(b)
a.append(5)
print(a)
print(b)
print(hex(id(a)))
print(hex(id(b)))