À quoi sert une liste ?
Une variable ordinaire ne retient qu'une valeur. Dès que tu veux garder les vingt premiers termes d'une suite, cent lancers simulés ou les notes d'une classe, il te faut un objet qui range plusieurs valeurs sous un seul nom : la liste. Tu la retrouves dans tous les algorithmes du programme : termes d'une suite, recherche d'un seuil, simulation, moyenne.
Tous les exemples sont en Python, et ce chapitre ne travaille qu'avec des listes.
Définir une liste et lire ses éléments
Liste en extension
Une liste est une suite ordonnée de valeurs, écrites entre crochets et séparées par des virgules. Définir une liste en extension, c'est écrire tous ses éléments un par un :
L = [3, 7, 7, 10]
Le nombre d'éléments d'une liste s'appelle sa longueur ; on l'obtient avec len(L). Ici, len(L) vaut . La liste vide s'écrit [] et sa longueur vaut .
Lien avec les ensembles
En mathématiques, un ensemble s'écrit aussi en extension : . Deux différences comptent :
- dans une liste, l'ordre compte :
[3, 7]et[7, 3]sont différentes, alors que ; - une valeur peut être répétée :
[3, 7, 7, 10]a quatre éléments, l'ensemble de ses valeurs n'en a que trois.
Indices
Chaque élément est repéré par sa position, son indice. La numérotation commence à : premier élément L[0], dernier L[len(L) - 1]. Avec L = [3, 7, 7, 10] :
| indice | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| élément | 3 | 7 | 7 | 10 |
L[0] vaut et L[3] vaut ; L[4] provoque une erreur, une liste de longueur n'ayant pas d'indice .
Générer une liste par ajouts successifs
Écrire une liste en extension devient impossible quand elle est longue : on part d'une liste vide et on la remplit dans une boucle avec L.append(x), qui ajoute x à la fin.
Rappel : range(n) fournit les entiers de à , et range(a, b) ceux de à .
Exemple travaillé : les termes d'une suite
On considère la suite définie par et . On veut la liste des termes de à .
u = 1
L = [u]
for n in range(4):
u = 2*u + 1
L.append(u)
Pas à pas : avant la boucle, u vaut et L vaut [1] ; puis , , , , et L vaut [1, 3, 7, 15, 31].
La liste a éléments : le terme initial, puis un par tour de boucle. Le terme est rangé à l'indice : L[3] vaut .
Générer une liste en compréhension
Le principe
Un ensemble se définit en compréhension par une propriété : . Python reprend cette idée :
C = [n**2 for n in range(5)]
« La liste des n**2, pour n de à » : on obtient [0, 1, 4, 9, 16]. Forme générale : [expression for variable in valeurs].
Avec une condition
On peut ne garder que les valeurs qui vérifient une condition, après le mot if. a % b est le reste de la division euclidienne de a par b : n % 2 == 0 signifie « n est pair ».
P = [n for n in range(10) if n % 2 == 0]
P vaut [0, 2, 4, 6, 8] : c'est la traduction de .
Les conditions se combinent avec les connecteurs logiques and (et), or (ou), not (non).
Exemple travaillé : « et » puis « ou »
A = [n for n in range(1, 21) if n % 2 == 0 and n % 3 == 0]
B = [n for n in range(1, 11) if n % 2 == 0 or n % 3 == 0]
- Pour
A,nparcourt les entiers de à et doit être multiple de et de , donc multiple de :Avaut[6, 12, 18]. - Pour
B,nparcourt à et doit être multiple de ou de (l'un, l'autre ou les deux) :Bvaut[2, 3, 4, 6, 8, 9, 10]. Le nombre vérifie les deux conditions, il n'apparaît qu'une fois.
On peut partir d'une liste existante : avec L = [12, 5, 19, 8], [x for x in L if x > 10] vaut [12, 19].
Manipuler les éléments d'une liste
Une liste se modifie après sa création. Voici les instructions à connaître.
| Instruction | Effet |
|---|---|
L[i] = v | remplace l'élément d'indice i par v |
L.append(x) | ajoute x à la fin |
L.insert(i, x) | insère x à l'indice i ; les éléments suivants sont décalés d'un rang |
L.remove(x) | supprime la première occurrence de la valeur x |
L.pop(i) | supprime l'élément d'indice i et renvoie sa valeur |
del L[i] | supprime l'élément d'indice i |
Exemple travaillé
On part de L = [4, 8, 15, 16] et on exécute les instructions dans l'ordre.
L.append(23):Lvaut[4, 8, 15, 16, 23].L.insert(1, 6): prend l'indice ,Lvaut[4, 6, 8, 15, 16, 23].L.remove(15): la valeur disparaît,Lvaut[4, 6, 8, 16, 23].L.pop(0): l'élément d'indice , soit , est supprimé et renvoyé ;Lvaut[6, 8, 16, 23].L[2] = 0:Lvaut[6, 8, 0, 23].
Chaque ajout ou suppression change la longueur et décale les indices des éléments suivants : la valeur était à l'indice , puis après l'insertion, puis après le pop(0).
Parcourir une liste par ses indices
Parcourir une liste, c'est passer en revue ses positions, de à len(L) - 1 : exactement range(len(L)).
for i in range(len(L)):
print(i, L[i])
Ce parcours est indispensable quand tu as besoin de la position d'un élément, ou quand tu veux modifier la liste.
Exemple travaillé : modifier chaque élément
L = [1, 5, 2]
for i in range(len(L)):
L[i] = 2 * L[i]
i prend les valeurs , , : L[0] devient , L[1] devient , L[2] devient . À la fin, L vaut [2, 10, 4].
Exemple travaillé : position du plus grand élément
L = [12, 5, 19, 8]
imax = 0
for i in range(1, len(L)):
if L[i] > L[imax]:
imax = i
- :
L[1]n'est pas supérieur àL[0],imaxreste ; - :
L[2],imaxdevient ; - :
L[3]n'est pas supérieur àL[2],imaxreste .
Le plus grand élément est donc à l'indice , et il vaut L[imax] .
Itérer sur les éléments d'une liste
Quand la position ne t'intéresse pas, tu peux faire prendre directement à une variable les valeurs successives de la liste :
for x in L:
print(x)
Ici x vaut tour à tour chaque élément (et non chaque indice), dans l'ordre de la liste. C'est la forme la plus lisible pour calculer une somme, compter ou chercher une valeur.
Exemple travaillé : somme, moyenne, comptage
L = [12, 5, 19, 8]
s = 0
c = 0
for x in L:
s = s + x
if x >= 10:
c = c + 1
m = s / len(L)
svaut successivement , , , : la somme des éléments est ;cpasse à pour , puis à pour : deux éléments sont supérieurs ou égaux à ;- : c'est la moyenne.
La variable s qui se remplit au fil de la boucle s'appelle un accumulateur, la variable c un compteur : les deux s'initialisent à avant la boucle.
Indices ou éléments : que choisir ?
- Tu dois modifier la liste ou connaître une position : parcours par indices,
for i in range(len(L)). - Tu dois seulement lire les valeurs : itération sur les éléments,
for x in L.
Les pièges
- Commencer les indices à 1. Le premier élément est
L[0], le dernierL[len(L) - 1].L[len(L)]provoque une erreur. - Confondre
removeetpop.L.remove(2)supprime la valeur ;L.pop(2)supprime l'élément d'indice . - Écrire
L = L.append(x). L'instructionL.append(x)modifie directementLet ne renvoie pas de liste : écris seulementL.append(x). - Se tromper sur la borne de
range.range(1, 10)s'arrête à ;range(5)fournit valeurs, de à . - Croire que
for x in Lmodifie la liste.x = 2 * xchange la variablex, pas l'élément. Pour modifier, passe par les indices :L[i] = 2 * L[i]. - Confondre
ietL[i]. Dansfor i in range(len(L)),iest une position ; la valeur estL[i]. - Confondre
=et==.=affecte une valeur,==teste une égalité : dans une condition, c'est toujours==. - Traiter une liste comme un ensemble. Elle garde l'ordre et les répétitions :
[1, 2]et[2, 1]diffèrent, et[1, 1, 2]a trois éléments. - Oublier d'initialiser. Un accumulateur, un compteur ou une liste vide se créent avant la boucle, jamais à l'intérieur.
Ce qu'il faut retenir
- Une liste s'écrit entre crochets :
L = [1, 5, 2]. Elle garde l'ordre et les répétitions, et sa longueur estlen(L). - Les indices vont de à
len(L) - 1: le premier élément estL[0], le dernierL[len(L) - 1]. - Deux façons de construire : par ajouts successifs (
L = []puisL.append(x)dans une boucle) ou en compréhension ([f(k) for k in range(n)], avec une condition facultativeif). - Modifier :
L[i] = v,L.append(x),L.insert(i, x),L.remove(x)(une valeur),L.pop(i)etdel L[i](un indice). Chaque ajout ou suppression décale les indices suivants. - Deux parcours :
for i in range(len(L))quand la position compte ou qu'il faut modifier la liste ;for x in Lquand seules les valeurs comptent. - Un accumulateur (
s = 0), un compteur (c = 0) ou une liste vide (L = []) s'initialisent avant la boucle. range(a, b)s'arrête à ;range(n)donne valeurs, de à .
À l'épreuve
Les sujets de 2024 et de 2025 comptent quatre exercices sur 20 points ; la forme de 2027 n'est pas confirmée ici. Justifie chaque réponse : un résultat sans justification ne montre pas ta démarche.
Les listes peuvent apparaître dans une question d'algorithmique à l'intérieur d'un autre exercice, par exemple sur les suites ou les probabilités. Des consignes de ce genre peuvent se présenter : « recopier et compléter la fonction ci-dessous », « que renvoie cette fonction ? », « que contient la liste L après exécution ? », « écrire une fonction qui renvoie la liste des premiers termes », « interpréter la valeur renvoyée dans le contexte de l'exercice ».
Soigne le code : initialisation avant la boucle, bons indices (range bien borné, pas de L[len(L)]), return au bon niveau d'indentation, et la valeur demandée, pas une autre. Quand la question demande d'interpréter, écris une phrase sur la situation, pas une paraphrase du code. Une exécution pas à pas se rédige en donnant les valeurs successives des variables, dans un tableau ou ligne par ligne.