insight.Se connecter

Mathématiques · Terminale

Notion de liste : cours et fiche de révision (Mathématiques, Terminale)

Programme officiel, session 2027. Mis à jour le 12 novembre 2026. 8 min de lecture.

Ce que contient ce chapitre

  • Définir une liste, lire ses éléments
  • Construire une liste par ajouts
  • Les listes en compréhension
  • Modifier, ajouter, supprimer
  • Parcourir une liste par ses indices
  • Itérer sur les éléments : calculer, compter, chercher

À 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 44. La liste vide s'écrit [] et sa longueur vaut 00.

Lien avec les ensembles

En mathématiques, un ensemble s'écrit aussi en extension : {3;7;10}\{3 ; 7 ; 10\}. Deux différences comptent :

  • dans une liste, l'ordre compte : [3, 7] et [7, 3] sont différentes, alors que {3;7}={7;3}\{3 ; 7\} = \{7 ; 3\} ;
  • 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 à 00 : premier élément L[0], dernier L[len(L) - 1]. Avec L = [3, 7, 7, 10] :

indice0123
élément37710

L[0] vaut 33 et L[3] vaut 1010 ; L[4] provoque une erreur, une liste de longueur 44 n'ayant pas d'indice 44.

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 00 à n−1n - 1, et range(a, b) ceux de aa à b−1b - 1.

Exemple travaillé : les termes d'une suite

On considère la suite (un)(u_n) définie par u0=1u_0 = 1 et un+1=2un+1u_{n+1} = 2u_n + 1. On veut la liste des termes de u0u_0 à u4u_4.

u = 1
L = [u]
for n in range(4):
    u = 2*u + 1
    L.append(u)

Pas à pas : avant la boucle, u vaut 11 et L vaut [1] ; puis u=3u = 3, 77, 1515, 3131, et L vaut [1, 3, 7, 15, 31].

La liste a 55 éléments : le terme initial, puis un par tour de boucle. Le terme unu_n est rangé à l'indice nn : L[3] vaut u3=15u_3 = 15.

Générer une liste en compréhension

Le principe

Un ensemble se définit en compréhension par une propriété : {n2∣n∈N, n⩽4}\{n^2 \mid n \in \mathbb{N},\ n \leqslant 4\}. Python reprend cette idée :

C = [n**2 for n in range(5)]

« La liste des n**2, pour n de 00 à 44 » : 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 {n∈N∣n<10 et n pair}\{n \in \mathbb{N} \mid n < 10 \text{ et } n \text{ pair}\}.

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, n parcourt les entiers de 11 à 2020 et doit être multiple de 22 et de 33, donc multiple de 66 : A vaut [6, 12, 18].
  • Pour B, n parcourt 11 à 1010 et doit être multiple de 22 ou de 33 (l'un, l'autre ou les deux) : B vaut [2, 3, 4, 6, 8, 9, 10]. Le nombre 66 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.

InstructionEffet
L[i] = vremplace 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.

  1. L.append(23) : L vaut [4, 8, 15, 16, 23].
  2. L.insert(1, 6) : 66 prend l'indice 11, L vaut [4, 6, 8, 15, 16, 23].
  3. L.remove(15) : la valeur 1515 disparaît, L vaut [4, 6, 8, 16, 23].
  4. L.pop(0) : l'élément d'indice 00, soit 44, est supprimé et renvoyé ; L vaut [6, 8, 16, 23].
  5. L[2] = 0 : L vaut [6, 8, 0, 23].

Chaque ajout ou suppression change la longueur et décale les indices des éléments suivants : la valeur 88 était à l'indice 11, puis 22 après l'insertion, puis 11 après le pop(0).

Parcourir une liste par ses indices

Parcourir une liste, c'est passer en revue ses positions, de 00 à 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 00, 11, 22 : L[0] devient 22, L[1] devient 1010, L[2] devient 44. À 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
  • i=1i = 1 : L[1] =5= 5 n'est pas supérieur à L[0] =12= 12, imax reste 00 ;
  • i=2i = 2 : L[2] =19>12= 19 > 12, imax devient 22 ;
  • i=3i = 3 : L[3] =8= 8 n'est pas supérieur à L[2] =19= 19, imax reste 22.

Le plus grand élément est donc à l'indice 22, et il vaut L[imax] =19= 19.

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)
  • s vaut successivement 1212, 1717, 3636, 4444 : la somme des éléments est 4444 ;
  • c passe à 11 pour x=12x = 12, puis à 22 pour x=19x = 19 : deux éléments sont supérieurs ou égaux à 1010 ;
  • m=44/4=11m = 44 / 4 = 11 : 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 à 00 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 dernier L[len(L) - 1]. L[len(L)] provoque une erreur.
  • Confondre remove et pop. L.remove(2) supprime la valeur 22 ; L.pop(2) supprime l'élément d'indice 22.
  • Écrire L = L.append(x). L'instruction L.append(x) modifie directement L et ne renvoie pas de liste : écris seulement L.append(x).
  • Se tromper sur la borne de range. range(1, 10) s'arrête à 99 ; range(5) fournit 55 valeurs, de 00 à 44.
  • Croire que for x in L modifie la liste. x = 2 * x change la variable x, pas l'élément. Pour modifier, passe par les indices : L[i] = 2 * L[i].
  • Confondre i et L[i]. Dans for i in range(len(L)), i est une position ; la valeur est L[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 est len(L).
  • Les indices vont de 00 à len(L) - 1 : le premier élément est L[0], le dernier L[len(L) - 1].
  • Deux façons de construire : par ajouts successifs (L = [] puis L.append(x) dans une boucle) ou en compréhension ([f(k) for k in range(n)], avec une condition facultative if).
  • Modifier : L[i] = v, L.append(x), L.insert(i, x), L.remove(x) (une valeur), L.pop(i) et del 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 L quand 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 à b−1b - 1 ; range(n) donne nn valeurs, de 00 à n−1n-1.

À 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 nn 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.

À retenir

  • Définir une liste, lire ses éléments

    Une liste s'écrit entre crochets : L = [3, 7, 7, 10]. L'ordre compte et une valeur peut être répétée, contrairement à un ensemble.len(L) donne la longueur (ici 4) ; la liste vide [] a pour longueur 0.Les indices commencent à 0 : le premier élément est L[0], le dernier L[len(L) - 1].L[len(L)] provoque une erreur : cet indice n'existe pas.
  • Construire une liste par ajouts

    On part d'une liste vide L = [] (ou contenant le premier terme) créée avant la boucle.L.append(x) ajoute x à la fin de L.range(n) fournit les n entiers de 0 à n − 1 ; range(a, b) ceux de a à b − 1.Longueur finale = nombre d'éléments de départ + nombre de tours de boucle.On écrit L.append(x) seul, jamais L = L.append(x).
  • Les listes en compréhension

    Forme : [expression for variable in valeurs], par exemple [n**2 for n in range(5)] vaut [0, 1, 4, 9, 16].Avec un filtre : [n for n in range(10) if n % 2 == 0] vaut [0, 2, 4, 6, 8].a % b est le reste de la division de a par b ; == teste l'égalité.and : les deux conditions sont vraies ; or : au moins une est vraie ; not : la condition est fausse.C'est la traduction d'un ensemble défini en compréhension, mais l'ordre est conservé.
  • Modifier, ajouter, supprimer

    L[i] = v remplace l'élément d'indice i.L.append(x) ajoute à la fin ; L.insert(i, x) insère x à l'indice i et décale les suivants.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] le supprime aussi.Chaque ajout ou suppression change la longueur et décale les indices situés après.
  • Parcourir une liste par ses indices

    for i in range(len(L)): fait prendre à i les indices 0, 1, …, len(L) − 1.Dans cette boucle, i est une position et L[i] est la valeur rangée à cette position.C'est le parcours à utiliser pour modifier la liste (L[i] = 2 * L[i]) ou pour retenir une position (indice du maximum, indice d'une valeur cherchée).range(1, len(L)) démarre au deuxième élément.
  • Itérer sur les éléments : calculer, compter, chercher

    for x in L: fait prendre à x chaque élément de L, dans l'ordre.Somme : s = 0 avant la boucle, puis s = s + x à chaque tour.Comptage : c = 0 avant la boucle, puis c = c + 1 quand la condition est vraie.Moyenne : somme divisée par len(L).Modifier x dans la boucle ne modifie pas la liste.

Teste-toi

Trois questions. Réponds, la correction s’affiche.

Question 1 sur 3
On définit L = [5, 9, 2, 9]. Quelle est la valeur de L[1] ?

Correction

Les indices commencent à 00 : L[0] vaut 55 et L[1] vaut 99.La réponse est donc 99.Erreur classique : répondre 55 — tu comptes à partir de 11, alors que L[1] est le deuxième élément de la liste.
Question 2 sur 3
On exécute L = [5, 2, 9] puis L.insert(1, 7). Que vaut alors L ?

Correction

L.insert(1, 7) place 7 à l'indice 1, c'est-à-dire en deuxième position.Les éléments 2 et 9 sont décalés d'un rang : L vaut [5, 7, 2, 9].Erreur classique : répondre [7, 5, 2, 9] — les indices commencent à 0, donc l'indice 1 est la deuxième position.
Question 3 sur 3
On exécute le programme suivant.
L = [4, 9, 2]
s = 0
for x in L:
    s = s + x
Quelle est la valeur de s à la fin de l'exécution ?

Correction

x prend tour à tour les valeurs 4, 9, 2 et s les accumule.s vaut successivement 0 + 4 = 4, puis 4 + 9 = 13, puis 13 + 2 = 15.Erreur classique : répondre 2 — s = s + x ajoute x à l'ancienne valeur de s, il ne la remplace pas par x.

Dans Insight, ce chapitre a 123 questions, et l’app te les repose au bon moment pour que tu ne les oublies pas avant le bac.

Contenu préparé avec l’aide d’outils d’IA, vérifié.

Réviser ce chapitre gratuitement