Python

Un des points forts du langage Python est la création, la génération, l'analyse et la manipulation des listes. Nous allons découvrir ici la syntaxe de base et les méthodes natives liées aux listes en Python.

Tous les exemples suivants sont à tester dans la console d'EduPython afin de découvrir la manipulation des listes en Python.

Une liste s'écrit entre crochets et peut contenir des objets de différents types.

Remarque : la liste vide est la seule liste qui ne possède aucun élément.

Grâce à la concaténation et à la duplication il est possible de créer une liste à partir d'autres listes.

>>> 3*liste1
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> 4*["oui","non"]
['oui', 'non', 'oui', 'non', 'oui', 'non', 'oui', 'non']
>>> 7*[4]
[4, 4, 4, 4, 4, 4, 4]
>>> 4*[1,2,3]
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

En utilisant à la fois la concaténation (opérateur +) et la duplication (opérateur *) il est possible de créer en une seule ligne de code une liste complexe :

>>> liste=4*([1,2]+3*["A"])+2*(["oui"]+["2000"])
>>> print(liste)
[1, 2, 'A', 'A', 'A', 1, 2, 'A', 'A', 'A', 1, 2, 'A', 'A', 'A', 1, 2, 'A', 'A', 'A', 'oui', '2000', 'oui', '2000']

La fonction list convertit une chaîne de caractères (ou tout autre objet composé) en liste :

>>> list("bonjour")
['b', 'o', 'n', 'j', 'o', 'u', 'r']
>>> list({1,2,3,4})
[1, 2, 3, 4]
>>> list((1,2,3,4))
[1, 2, 3, 4]
>>> list(range(5))
[0, 1, 2, 3, 4]

Comme pour les chaînes de caractères, l'accès à un élément de la liste de fait par indexation à partir de zéro :

Un index négatif permet de partir de la fin de la liste (liste[-1] étant le dernier élément de la liste) :

>>> liste=[1,2,3,4,5,6]
>>> liste[-1]
6
>>> liste[-2]
5
>>> liste[-5]
2
>>> liste[-6]
1

Les indices commencent à 0. Par exemple pour une liste de 8 éléments les indices vont de 0 à 7 :

>>> liste=[1,2,3,4,5,6,7,8]
>>> liste[0]
1
>>> liste[1]
2
>>> liste[2]
3
>>> len(liste)
8
>>> liste[len(liste)-1]
8
>>> liste[7]
8

>>> liste=[1,2,3,4,5,6,7,8]
>>> liste[-1]
8
>>> liste[-2]
7
>>> liste[-3]
6
>>> liste[-4]
5
>>> liste[-7]
2
>>> liste[-8]
1

Comme pour les chaînes de caractères un système de tranchage utilisant le caractère deux points permet d'extraire facilement une partie de la liste :

>>> liste=[1,2,3,4,5,6]
>>> liste[0:4]
[1, 2, 3, 4]
>>> liste[1:4]
[2, 3, 4]
>>> liste[1:5]
[2, 3, 4, 5]
>>> liste[:3]
[1, 2, 3]
>>> liste[:6]
[1, 2, 3, 4, 5, 6]
>>> liste[2:]
[3, 4, 5, 6]
>>> liste[0:]
[1, 2, 3, 4, 5, 6]
>>> liste[:]
[1, 2, 3, 4, 5, 6]
>>> liste[0:6:2]
[1, 3, 5]
>>> liste[0:6:3]
[1, 4]

Python dispose d'une syntaxe à la fois simple et puissante pour extraire une sous-liste d'une liste, c'est-à-dire sélectionner certains éléments de la liste.

L'indice 2:4 écrit entre crochet est ici composé de 2 indexs (2 et 4) séparés par le caractère deux-points.

Le résultat obtenu est la sous-liste [11, 14], qui n'est peut-être pas le résultat que vous attendiez.

Le tranchage consiste à couper la liste "en tranche" et à en extraire certaines.

Pour bien comprendre la technique d'extraction d'une sous-liste par tranchage, il faut imaginer la liste comme étant un saucisson, les indexs étant des coupes et les éléments de la liste étant les tranches (la technique du "tranchage" est également appelé "saucissonage") :

En imaginant les indexs comme des coupes dans la liste, on constate que la sous-liste extraite par tranchage est l'ensemble des éléments encadrés par les indexs.

Réponse : liste[1:5] car les éléments à extraire sont encadrés par les indexs 1 et 5

Réponse : liste[3:5] car les éléments à extraire sont encadrés par les indexs 3 et 5

Question : quelle syntaxe permet d'extraire la même sous-liste [14, 3] mais en utilisant des indexs négatifs ?

Réponse : liste[-3:-1] car les éléments à extraire sont encadrés par les indexs négatifs -3 et -1

Question : quelle syntaxe permet d'extraire la sous-liste [7, 11, 14] en utilisant un index positif et un index négatif ?

Réponse : il y a cette fois 2 solutions : liste[1:-2] et liste[-5:4] qui donnent le même résultat :

Question : quelles sous-listes obtient-on avec les syntaxes liste[2:5], liste[2:-1], liste[-4:5] et liste[-4:-1] ?

Réponse : 4 fois la même sous-liste [11, 14, 3] car ces 4 écritures correspondent au même tranchage :

>>> liste[2:5]
[11, 14, 3]
>>> liste[2:-1]
[11, 14, 3]
>>> liste[-4:5]
[11, 14, 3]
>>> liste[-4:-1]
[11, 14, 3]

Dans l'indice écrit entre crochet, si le second index est égal au premier ou est à gauche du premier dans le découpage en tranches illustré ci-dessus alors la sous-liste sélectionnée sera la liste vide, qui s'écrit [] et qui ne contient aucun élément.

>>> liste[5:2]
[]
>>> liste[4:4]
[]
>>> liste[-2:-5]
[]
>>> liste[6:-4]
[]
>>> liste[-3:1]
[]

Si on ajoute un troisième chiffre dans l'indice entre crochet il correspond au "pas" et permet de sélectionner par exemple un élément sur 2 ou un élément sur 3.

>>> liste[0:6:2]
[18, 11, 3]
>>> liste[1:6:2]
[7, 14, 9]
>>> liste[0:6:3]
[18, 14]
>>> liste[1:6:3]
[7, 3]

Un indice composé d'un chiffre suivi de deux-point extrait une sous-liste allant de l'index indiqué jusqu'à la fin de la liste.

>>> liste[0:]
[18, 7, 11, 14, 3, 9]
>>> liste[1:]
[7, 11, 14, 3, 9]
>>> liste[3:]
[14, 3, 9]
>>> liste[4:]
[3, 9]

Un indice composé de deux-point suivi d'un chiffre extrait une sous-liste allant du début de la liste jusqu'à l'index indiqué.

>>> liste[:6]
[18, 7, 11, 14, 3, 9]
>>> liste[:5]
[18, 7, 11, 14, 3]
>>> liste[:3]
[18, 7, 11]
>>> liste[:1]

Un indice composé seulement du caractère deux-point (sans indexs chiffrés) sélectionne la liste entière :

>>> liste=[1,2,3,4,5,6,7,8]
>>> liste[2:4]
[3, 4]
>>> liste[2:5]
[3, 4, 5]
>>> liste[2:]
[3, 4, 5, 6, 7, 8]
>>> liste[:3]
[1, 2, 3]
>>> liste[:5]
[1, 2, 3, 4, 5]
>>> liste[:]
[1, 2, 3, 4, 5, 6, 7, 8]

Extrait une tranche de liste (sous forme d'une liste) avec des indices négatifs :

>>> liste=[1,2,3,4,5,6,7,8]
>>> liste[-5:-2]
[4, 5, 6]
>>> liste[2:-3]
[3, 4, 5]
>>> liste[3:-1]
[4, 5, 6, 7]
>>> liste[-6:-5]
[3]
>>> liste[2:3]
[3]
>>> liste[2]
3

Avec 3 paramètres, la syntaxe d'extraction d'une tranche (avec les deux points) permet de sélectionner un élément sur 2, ou sur 3, etc.

>>> liste[0:8]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> liste[0:8:2]
[1, 3, 5, 7]
>>> liste[0:8:3]
[1, 4, 7]
>>> liste[1:8:2]
[2, 4, 6, 8]

Exemple d'application : extrait seulement les nombres pairs ou impairs d'une liste d'entiers ordonnée :

>>> list(range(20))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> list(range(20))[5]
5
>>> list(range(20))[0:20]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> list(range(20))[0:20:2]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> list(range(20))[1:20:2]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Avec un indice direct (positif ou négatif) le dépassement d'indice est interdit et provoque une erreur :

>>> liste=[1,2,3,4,5]
>>> liste[8]
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
IndexError: list index out of range
>>> liste[-7]
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
IndexError: list index out of range

Avec la syntaxe des tranches, le dépassement d'indice est autorisé et ne provoque pas d'erreur. Seul les éléments réels de la liste présents dans l'intervalle sont sélectionnés :

>>> liste=[1,2,3,4,5]
>>> liste[-7:8]
[1, 2, 3, 4, 5]
>>> liste[-2:36]
[4, 5]
>>> liste[19:36]
[]

>>> liste=range(10)
>>> liste
range(0, 10)
>>> list(liste)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Remarque : la fonction range() ne renvoie pas directement une liste. Pour obtenir un objet de type liste il faut le convertir grâce à la fonction list qui converti en liste tout objet.

Avec un seul paramètre range(n) crée une liste numérique contenant les entiers de 0 à n-1 (par pas de 1) :

>>> list(range(20))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Avec 2 paramètres range(n,m) crée une liste numérique contenant les entiers de n à m-1 (par pas de 1) :

Avec 3 paramètres range(n,m,k) crée une liste numérique contenant les entiers de n à m-1 par pas de k :

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1,20))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> list(range(14,31))
[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
>>> list(range(3,40,2))
[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39]
>>> list(range(3,40,3))
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39]
>>> list(range(3,40,4))
[3, 7, 11, 15, 19, 23, 27, 31, 35, 39]

Python possède un grand nombre de fonctions et de méthodes permettant une manipulation avancée des listes afin d'y effectuer un traitement fin.

Rappel : le dernier élément d'une liste peut aussi s'obtenir plus simplement par liste[-1]

La liste vide, qui se note [], est la seule liste qui ne possède aucun élément. La fonction len renvoie alors la valeur 0 :

Pour tester si un élément appartient ou pas à une liste Python propose 2 solutions :

Le mot clé in permet de vérifier si un élément appartient à une liste. Le résultat est booléen (VRAI ou FAUX) :

La méthode count() permet de compter le nombre d'occurance d'un élément. Si un élément est présent une seule fois dans la liste la méthode count() renvoie 1 :

Si l'élément recherché n'est pas présent dans la liste la méthode count renvoie 0 :

En cas de doublons (plusieurs fois le même élément dans la liste), la méthode count() renvoie le nombre d'occurance d'un élément particulier :

>>> liste=[8,9,7,4,7,4,4,4,7,4,9,9,7,8,4,4,7,9]
>>> liste.count(4)
7
>>> liste.count(7)
5
>>> liste.count(8)
2
>>> liste.count(9)
4

>>> liste=[1,2,3]
>>> liste
[1, 2, 3]
>>> liste.append(4)
>>> liste
[1, 2, 3, 4]

Remarque : l'élément ajouté dans la liste par append est toujours ajouté à la fin de la liste.

La méthode insert permet d'insérer un nouvel élément à une position quelconque dans la liste. Par exemple pour insérer l'élément 6 à la position 2 il faut utilisert la syntaxe liste.insert(2,6) :

Insérons la lettre D : elle doit être insérer à la position 3 (liste[3] devra renvoyer 'D'). Pour cela on utilise la syntaxe liste.insert(3,'D') :

Insérons maintenant la lettre G. Comme on veut la lettre G à la position 6 de la liste on écrit liste.insert(6,'G') :

Ainsi, après 2 insertions, on obtient la liste complète des lettres de 'A' à 'H'.

>>> liste=[1,2,3,4,5,6,7,8,9]
>>> liste
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del liste[0]
>>> liste
[2, 3, 4, 5, 6, 7, 8, 9]
>>> del liste[4]
>>> liste
[2, 3, 4, 5, 7, 8, 9]
>>> del liste[1]
>>> liste
[2, 4, 5, 7, 8, 9]
>>> del liste[-1]
>>> liste
[2, 4, 5, 7, 8]
>>> del liste[-3]
>>> liste
[2, 4, 7, 8]

Grâce à la syntaxe des tranches la fonction del permet de supprimer directement une partie de la liste :

>>> liste=[1,2,3,4,5,6,7,8,9]
>>> liste[2:6]
[3, 4, 5, 6]
>>> del liste[2:6]
>>> liste
[1, 2, 7, 8, 9]

Remarque : avec la fonction del il faut préciser la position de l'élément à supprimer.

>>> liste=['A','B','C','D','E','F']
>>> liste
['A', 'B', 'C', 'D', 'E', 'F']
>>> liste.remove('C')
>>> liste
['A', 'B', 'D', 'E', 'F']

Remarque : avec la méthode remove il faut préciser la valeur de l'élément à supprimer.

En cas de doublons la méthode remove supprimera de la liste seulement la première occurance trouvée :

>>> liste=[1,2,3,1,2,3,1,2,3]
>>> liste
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> liste.remove(2)
>>> liste
[1, 3, 1, 2, 3, 1, 2, 3]
>>> liste.remove(2)
>>> liste
[1, 3, 1, 3, 1, 2, 3]
>>> liste.remove(3)
>>> liste
[1, 1, 3, 1, 2, 3]

Trier une liste signifie ordonner ces éléments afin qu'ils soient rangés dans l'ordre croissant.

La fonction sorted() renvoie une nouvelle liste sans modifier la liste originale :

>>> liste=[7,3,9,1,4]
>>> liste
[7, 3, 9, 1, 4]
>>> sorted(liste)
[1, 3, 4, 7, 9]
>>> liste
[7, 3, 9, 1, 4]

la méthode sort() modifie la position des éléments dans une liste afin de l'ordonner :

>>> liste=[7,3,9,1,4]
>>> liste
[7, 3, 9, 1, 4]
>>> liste.sort()
>>> liste
[1, 3, 4, 7, 9]

Pour mélanger une liste il faut utiliser la fonction shuffle du module random :

>>> import random
>>> liste=list(range(10))
>>> liste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(liste)
>>> liste
[8, 1, 6, 5, 7, 0, 2, 4, 3, 9]
>>> random.shuffle(liste)
>>> liste
[6, 5, 8, 7, 9, 3, 2, 1, 4, 0]

>>> liste=[1,2,3,4]
>>> liste
[1, 2, 3, 4]
>>> liste.reverse()
>>> liste
[4, 3, 2, 1]

La méthode extend permet d'allonger une liste en y ajoutant plusieurs nouveaux éléments à partir d'une autre liste :

>>> liste=[1,2,3,4]
>>> liste
[1, 2, 3, 4]
>>> liste.extend([5,6])
>>> liste
[1, 2, 3, 4, 5, 6]
>>> liste.extend([7,8,9])
>>> liste
[1, 2, 3, 4, 5, 6, 7, 8, 9]

La méthode index renvoie la position d'un élément dans la liste (c'est-à-dire son indice en partant de 0 pour le premier élément) :

>>> liste=[1,2,3,4]
>>> liste.index(3)
2
>>> liste=['A','B','C','D','E','F']
>>> liste.index('E')
4

Si l'élément recherché n'existe pas, alors la méthode index renvoie une erreur :

>>> liste=['A','B','C','D','E','F']
>>> liste.index('H')
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
ValueError: 'H' is not in list

En cas de doublons la méthode index renvoie la position de la première occurance trouvée :

La méthode pop renvoie le dernier élément de la liste et le supprime de la liste :

>>> liste=['A','B','C','D','E','F']
>>> liste.pop()
'F'
>>> liste
['A', 'B', 'C', 'D', 'E']
>>> liste.pop()
'E'
>>> liste
['A', 'B', 'C', 'D']
>>> liste.pop()
'D'
>>> liste
['A', 'B', 'C']

>>> liste=[8,5]
>>> liste
[8, 5]
>>> liste.pop()
5
>>> liste
[8]
>>> liste.pop()
8
>>> liste
[]
>>> liste.pop()
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
IndexError: pop from empty list

Il existe 3 opérateurs applicables sur des listes en Python, les voici :

Les opérateurs applicables sur une liste
opérateur	opération effectuée
+	concaténation de deux listes
*	duplication d'une liste
in	test d'appartenance à une liste

Voici les fonctions Python applicables à une liste :

Les fonctions externes applicables à une liste
fonction	opération effectuée
len	renvoie la longueur de la liste (nombre d'éléments)
del	supprime un ou plusieurs éléments dans la liste
sorted	renvoie la liste avec les éléments rangés dans l'ordre croissant (trie une liste)
shuffle	mélange une liste (importer le module random pour utiliser shuffle)

Il existe 9 méthodes applicables à un objet liste en Python, les voici :

Les méthodes propres à une liste
méthode	opération effectuée
append	ajoute un nouvel élément à la fin de la liste
count	renvoie le nombre d'occurrence d'un élément dans la liste
extend	allonge la liste avec une autre liste
reverse	inverse l'ordre des éléments dans la liste
sort	ordonne les éléments de la liste dans l'ordre croissant
insert	ajoute un nouvel élément à une position particulière
remove	supprime un élément de la liste (le premier trouvé en cas de doublons)
index	renvoie l'index d'un élément (le premier trouvé en cas de doublons)
pop	renvoie le dernier élément et le supprime de la liste

La technique de tranchage permet d'extraire une sous-liste d'une liste en utilisant une syntaxe simple :

Extraction d'une sous-liste par tranchage
syntaxe	éléments sélectionnés
liste[n]	extrait seulement l'élément d'indice n (pas une sous-liste)
liste[n:m]	extrait la sous-liste composée des éléments compris entre les indexs n et m
liste[n:m:k]	extrait la sous-liste composée des éléments compris entre les indexs n et m par pas de k
liste[n:]	tous les éléments de n jusqu'à la fin de la liste
liste[:m]	tous les éléments du début de la liste jusqu'à m
liste[:]	la liste entière
liste[::k]	un élément sur k dans la liste entière

Remarque : dans la syntaxe du tranchage les entiers n, m et k peuvent être aussi bien positifs (parcourt de la liste du début vers la fin) que négatifs (parcourt de la liste de la fin vers le début).