Ce contenu a été rédigé par l'équipe éditoriale de Kartable.
Dernière modification : 06/11/2026 - Conforme au programme 2026-2027
La génération d'une liste
Définition et notation
Liste
Une liste est un objet algorithmique servant à stocker plusieurs variables au cours d'un programme. Les variables stockées peuvent être de différents types : variables numériques, chaînes de caractères, booléens, listes, etc. Les différents types de variables peuvent être mélangés au sein d'une même liste.
| Instruction Python | Rôle de l'instruction |
| \verb!liste1=[]! | définit la liste \verb~liste1~ comme la liste vide |
| \verb!liste2=[3, 4.5, x]! | définit la liste \verb~liste2~ comme la liste contenant l'entier 3, le flottant 4.5 et la variable x |
| \verb!liste3=['Bonjour', -5, t]! | définit la liste \verb~liste3~ comme la liste contenant la chaîne de caractères 'Bonjour', l'entier -5 et la variable t |
| \verb!liste4=[0, [1, 2], "essai", True]! | définit la liste \verb~liste4~ comme la liste contenant l'entier 0, la liste \verb~[1, 2]~, la chaîne de caractères \verb~essai~ et le booléen \verb~True~ |
Une liste peut être nommée comme on le souhaite. Les éléments d'une liste se trouvent entre des crochets : [\dots]. Les éléments sont séparés par des virgules.
| \verb!liste1=[]! |
| \verb!liste2=[3, 4.5, x]! |
| \verb!liste3=['Bonjour', -5, t]! |
| \verb!liste4=[0, [1, 2], "essai", True]! |
Génération en extension
Générer une liste en extension, c'est écrire explicitement tous ses éléments entre crochets, séparés par des virgules.
L'instruction suivante génère en extension la liste des cinq premiers nombres impairs :
impairs = [1, 3, 5, 7, 9]
Cette écriture est celle d'un ensemble défini en extension : l'ensemble \{1 ; 3 ; 5 ; 7 ; 9\} et la liste [1, 3, 5, 7, 9] sont écrits en énumérant leurs éléments. À la différence d'un ensemble, une liste est ordonnée et peut contenir plusieurs fois le même élément.
Les listes [1, 2, 3] et [3, 2, 1] sont deux listes différentes, alors que \{1 ; 2 ; 3\} et \{3 ; 2 ; 1\} désignent le même ensemble. La liste [2, 2, 5] contient trois éléments, alors que l'ensemble \{2 ; 2 ; 5\} n'est autre que \{2 ; 5\}.
Les trois modes de génération d'une liste
Une liste peut être générée de trois façons : par ajouts successifs, en partant d'une liste vide que l'on complète ; en compréhension, en indiquant la règle qui produit chaque élément ; en extension, en écrivant tous ses éléments.
On peut générer une liste par ajouts successifs d'éléments. En Python, on utilise la méthode \verb~.append()~. Elle sert à ajouter un élément à la fin d'une liste.
Le programme Python suivant crée une liste \verb~liste1~ vide, puis ajoute les carrés des entiers de 0 à 10 :
On obtient l'affichage suivant :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100].
Une autre façon de générer une liste est celle dite en compréhension. Elle est plus courte et plus explicite que les précédentes. Certains langages de programmation, comme Python, permettent de définir une liste en indiquant la façon dont sont générés les éléments de la liste.
Le programme Python suivant crée la liste des carrés des entiers de 0 à 10 d'une autre façon :
On obtient l'affichage suivant :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100].
On peut ajouter des conditions dans une liste créée en compréhension.
Le programme suivant crée la liste des carrés des entiers de 0 à 10 mais ne conserve que les résultats strictement supérieurs à 50 :
On obtient : \verb~[64, 81, 100]~.
Si on utilise juste l'instruction \verb~range(11)~, Python ne crée pas une liste. Pour générer la liste des entiers de 0 à 10 (inclus), on doit utiliser l'instruction \verb~list~ comme suit :
\verb~list(range(11))~.
On peut ajouter à une liste tous les éléments d'une autre liste en ajoutant les éléments d'une deuxième liste à la fin d'une première liste. En Python, on utilise la méthode \verb~.extend()~.
Le programme Python suivant crée deux listes \verb~liste1~ et \verb~liste2~, puis étend la liste \verb~liste1~ avec les éléments de la liste \verb~liste2~ :
On obtient : \verb~[1, 2, 3, 10, 20, 30]~.
Une autre façon d'ajouter les éléments d'une liste à la fin d'une autre est la concaténation. Il a exactement le même effet que le précédent. La différence réside dans le fait de ne pas utiliser de méthode mais une "opération".
Le programme suivant donne le même résultat que le précédent mais en utilisant la concaténation :
La duplication permet le « recopiage » d'une liste au bout d'elle-même. On peut concaténer la liste avec elle-même plusieurs fois de suite.
Le programme Python suivant duplique 5 fois \verb~liste1~ pour n'en faire qu'une liste :
On obtient : \verb![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]!.
La manipulation des éléments d'une liste
Indice d'un élément
On appelle indice d'un élément d'une liste sa position dans la liste. En Python, le premier élément d'une liste a pour indice 0 : la numérotation des indices commence à 0.
En Python, le premier élément d'une liste est de rang 0. La numérotation des éléments démarre donc à 0.
Dans la liste Python \verb~[5, 10, 15]~, on a :
- le nombre 5 est l'élément d'indice 0,
- le nombre 10 est l'élément d'indice 1,
- le nombre 15 est l'élément d'indice 2.
Longueur d'une liste
On appelle longueur d'une liste le nombre d'éléments d'une liste.
En Python, la longueur de la liste \verb~liste1~ s'obtient avec l'instruction :
\verb!len(liste1)!.
La liste \verb~[5, 10, 15]~ a pour longueur 3.
Manipuler les éléments d'une liste nécessite souvent d'être capable de prendre un élément de rang donné dans une liste. Les instructions suivantes sont à connaître lorsque l'on écrit un programme Python :
| Instruction Python | Rôle de l'instruction |
| \verb!liste1[i]! | affiche l'élément de rang \verb~i~ de la liste \verb~liste1~ |
| \verb!liste1[2:5]! | affiche les éléments de la liste \verb~liste1~ du rang 2 au rang 5 (non compris) |
| \verb!liste1[-1]! | affiche dernier élément de la liste \verb~liste1~ |
| \verb!liste1[-4:]! | affiche les 4 derniers éléments de la liste \verb~liste1~ |
| \verb!liste1[::3]! | renvoie une liste formée des termes de la liste \verb~liste1~ de rangs multiples de 3 |
| \verb!liste1.index(x)! | retrouve le rang de l'élément \verb~x~ dans la liste \verb~liste1~ |
| \verb!liste1.count(a)! | compte le nombre d'occurrences de \verb~a~ dans la liste \verb~liste1~ |
| \verb~a in liste1~ | teste si l'élément \verb~a~ est dans la liste \verb~liste1~ et renvoie \verb~True~ si c'est le cas et \verb~False~ sinon |
On peut manipuler les éléments d'une liste d'un grand nombre de façons.
Le tableau suivant montre quelques exemples en Python :
| Instruction Python | Rôle de l'instruction |
| \verb!liste1[i]=a! | remplace l'élément de rang \verb~i~ par \verb~a~ |
| \verb!liste1.insert(i,x)! | insère l'élément \verb~x~ dans la liste \verb~liste1~ au rang \verb~i~ |
| \verb!liste1.remove(x)! | supprime la première occurrence de \verb~x~ dans la liste \verb~liste1~ |
| \verb!liste1.pop(i)! ou \verb!del(liste1[i])! | supprime l'élément d'indice \verb~i~ dans la liste \verb~liste1~ |
| \verb!liste1.sort()! | modifie la liste \verb~liste1~ en triant les éléments dans l'ordre croissant |
| \verb!liste2=sorted(liste1)! | trie la liste \verb~liste1~ et stocke le résultat dans \verb!liste2!. La liste \verb~liste1~ n'est pas modifiée. |
| \verb!liste1.reverse()! | inverse les éléments de la liste \verb~liste1~ (ainsi que les autres listes qui lui sont égales) |
| \verb~liste2=liste1[::-1]~ | définit la liste \verb~liste2~ comme étant la liste \verb~liste1~ dans l'ordre inverse mais ne modifie pas \verb~liste1~ |
On peut également effectuer des transformations entre chaînes de caractères et listes.
Le programme suivant transforme la chaîne \verb~chaine~ en une liste de chaînes de caractères en utilisant l'espace comme séparateur pour couper la chaîne :
On obtient : \verb~['Bonjour', 'à', 'tous']~.
Le programme suivant transforme la liste \verb~liste1~ en une chaîne de caractères en ajoutant un espace entre chaque élément de la liste \verb~liste1~:
On obtient : \verb~Bonjour à tous !~.
Les itérations sur les éléments d'une liste et le parcours d'une liste
On peut parcourir les éléments d'une liste en utilisant leurs indices.
Le programme en Python suivant affiche les éléments de la liste \verb~liste1~ un par un :
Itérer sur les éléments d'une liste, c'est parcourir directement ses éléments sans utiliser leurs indices, avec une boucle de la forme for element in liste. Chaque élément est désigné tour à tour par la variable de boucle.
On peut également parcourir une liste sans avoir recours aux indices.
Le programme suivant affiche également les éléments de la liste \verb~liste1~ un par un :
On peut également appliquer une fonction à tous les éléments d'une liste.
Le programme en Python suivant applique la fonction f:x\mapsto 2x^2+3x+1 à tous les éléments de la liste \verb~liste1~ :
On obtient : \verb~[1, 6, 15, 28, 45, 66, 91, 120, 153, 190, 231]~.