Les listes en Python : cours de 2de

Publié le 9 novembre 2026 · Mis à jour le 9 novembre 2026 · Signaler une erreur

L'essentiel

Une liste est une suite ordonnée de valeurs écrite entre crochets, par exemple L = [4, 7, 1] ; ses éléments sont repérés par un indice qui commence à 0.
len(L) donne le nombre d'éléments ; le dernier a l'indice len(L) - 1, ou -1. Hors de ces limites : erreur IndexError.
On parcourt une liste avec for x in L (on veut les valeurs) ou for i in range(len(L)) (on veut aussi les positions).
On construit une liste en partant de [] et en ajoutant avec L.append(x), ou en une ligne avec une compréhension : [k**2 for k in range(1, 6)].
Une fonction peut recevoir une liste et en renvoyer une avec return : c'est ainsi qu'on programme les chiffres d'un nombre, sa factorisation ou le crible d'Ératosthène.

Pourquoi utiliser des listes ?

Jusqu'ici, tu as manipulé des variables qui contiennent une seule valeur : un entier, un décimal, un texte. C'est suffisant pour calculer l'aire d'un rectangle, mais pas pour traiter vingt notes, la liste des diviseurs d'un entier ou les chiffres d'un nombre. Imagine devoir écrire note1, note2, … note20 : ce serait long, et impossible à parcourir avec une boucle.

La liste règle ce problème. Elle range plusieurs valeurs dans une seule variable, dans un ordre précis, et permet de les traiter une par une, ou toutes ensemble, avec les boucles que tu connais déjà.

Python est un langage de programmation interprété, doté d'un typage dynamique : une même variable peut recevoir successivement un entier puis un texte, et Python devine le type tout seul ⁴. Il est aussi réputé pour sa syntaxe simple, ce qui en fait un bon langage pour débuter ⁴. Au lycée, c'est lui qu'on utilise pour la partie « algorithmique et programmation » du programme de mathématiques de seconde ³.

Les listes peuvent servir dans des activités de programmation proposées pour la seconde, comme trouver le nombre de chiffres d'un entier, encadrer $\sqrt{2}$ ou étudier un tremplin de ski ¹. Dans ce cours, tu vas apprendre à :

créer une liste et lire ou modifier ses éléments ;
la parcourir avec des boucles ;
la construire petit à petit, puis en une seule ligne ;
l'utiliser dans des fonctions et dans trois applications mathématiques classiques.

Créer une liste et lire ses éléments

DéfinitionListe

Une liste est une suite ordonnée d'éléments, écrits entre crochets et séparés par des virgules. Elle peut contenir des nombres, des textes, des booléens, et même un mélange.

notes = [12, 15, 9, 14]
mots = ["un", "deux", "trois"]
vide = []

La liste vide ne contient aucun élément.

ExempleLire des éléments

L = [10, 20, 30, 40]
print(L[0])      # affiche 10
print(L[2])      # affiche 30
print(len(L))    # affiche 4
print(L[3])      # affiche 40, le dernier

La liste a 4 éléments, donc les indices valides sont 0, 1, 2 et 3. L'élément d'indice 3 est le dernier, pas le troisième : c'est un décalage de un par rapport à notre façon habituelle de compter.

Indices positifs et négatifs de la liste L = [10, 20, 30, 40]
Valeur	10	20	30	40
Indice positif	0	1	2	3
Indice négatif	-4	-3	-2	-1

Indices positifs et négatifs de la liste L = [10, 20, 30, 40] · Chaque élément a deux indices possibles : un depuis le début, un depuis la fin.

Attention, erreur fréquenteL'erreur IndexError

Demander un indice qui n'existe pas arrête le programme.

L = [10, 20, 30, 40]
print(L[4])   # IndexError : list index out of range

Avec 4 éléments, L[4] n'existe pas : le dernier indice est 3. Quand tu vois « list index out of range », compare l'indice demandé à len(L) - 1.

MéthodeModifier un élément

Contrairement à un texte, une liste peut être modifiée en place. On affecte une nouvelle valeur à une case :

L = [10, 20, 30, 40]
L[1] = 25
print(L)   # affiche [10, 25, 30, 40]

La case d'indice 1 contenait 20 ; elle contient maintenant 25. Les autres cases n'ont pas bougé, et la longueur est restée la même.

Parcourir une liste avec des boucles

Parcourir une liste, c'est passer en revue ses éléments, un par un, pour les afficher, les compter, les additionner ou les tester. Python offre deux façons de le faire avec une boucle for, et tu choisis selon ce dont tu as besoin.

MéthodePremière façon : parcourir les valeurs

Si seules les valeurs t'intéressent, la variable de boucle prend directement chaque élément.

notes = [12, 15, 9, 14]
for x in notes:
    print(x)

À chaque tour, x vaut successivement 12, puis 15, puis 9, puis 14. C'est la forme la plus lisible : à privilégier quand la position ne sert pas.

MéthodeSeconde façon : parcourir les indices

Si tu as besoin de la position, ou si tu veux modifier la liste, tu parcours les indices avec range(len(L)).

notes = [12, 15, 9, 14]
for i in range(len(notes)):
    print(i, notes[i])

Ici, i prend les valeurs 0, 1, 2, 3 ; notes[i] est l'élément correspondant. L'affichage est : 0 12, 1 15, 2 9, 3 14.

ExempleSomme et moyenne : le schéma de l'accumulateur

Pour calculer la somme des éléments, on utilise une variable qui accumule le résultat, initialisée avant la boucle.

notes = [12, 15, 9, 14]
somme = 0
for x in notes:
    somme = somme + x
moyenne = somme / len(notes)
print(somme, moyenne)

Suivi des valeurs de somme : 0, puis 12, puis 27, puis 36, puis 50. La moyenne est donc $\dfrac{50}{4} = 12{,}5$ .

Astuce : Python propose aussi sum(notes), qui donne directement 50. Mais écrire la boucle à la main reste l'objectif du programme : elle montre ce que fait la machine.

ExempleChercher le plus grand élément

L = [7, 3, 12, 5]
maxi = L[0]
for x in L:
    if x > maxi:
        maxi = x
print(maxi)   # affiche 12

On commence avec le premier élément comme candidat, puis on le remplace chaque fois qu'on rencontre mieux. maxi prend les valeurs 7, puis 12, et ne bouge plus ensuite.

ExempleCompter les éléments qui vérifient une condition

Combien de nombres pairs dans la liste ?

L = [7, 3, 12, 5, 8, 20]
compteur = 0
for x in L:
    if x % 2 == 0:
        compteur = compteur + 1
print(compteur)   # affiche 3

Les nombres pairs sont 12, 8 et 20. Le test x % 2 == 0 signifie que le reste de la division de x par 2 est nul.

MéthodeParcours avec while

Une boucle while convient quand on ne sait pas à l'avance combien de tours seront nécessaires, ou quand on s'arrête dès qu'une condition est remplie. Voici la recherche de la première valeur négative :

L = [4, 8, -3, 6, -1]
i = 0
while i < len(L) and L[i] >= 0:
    i = i + 1

À la sortie, i vaut 2 : c'est l'indice de la première valeur négative. Si aucune valeur n'était négative, i vaudrait len(L). La condition i < len(L) est placée avant L[i] >= 0 pour ne jamais lire un indice qui n'existe pas.

Construire une liste : append et range

Souvent, on ne connaît pas la liste au départ : c'est le programme qui la fabrique. Le schéma est toujours le même : on part d'une liste vide, puis on ajoute des éléments au fil d'une boucle.

DéfinitionLa méthode append

Pour ajouter un élément à la fin d'une liste, on écrit L.append(x). La liste est modifiée en place et sa longueur augmente de 1.

L = []
L.append(5)
L.append(8)
print(L)   # affiche [5, 8]

ExempleLes carrés des premiers entiers

carres = []
for k in range(1, 6):
    carres.append(k * k)
print(carres)   # affiche [1, 4, 9, 16, 25]

range(1, 6) produit 1, 2, 3, 4, 5 : la borne de droite est exclue. Chaque tour ajoute le carré de k.

ExempleLes diviseurs d'un entier

def diviseurs(n):
    L = []
    for d in range(1, n + 1):
        if n % d == 0:
            L.append(d)
    return L

print(diviseurs(12))   # affiche [1, 2, 3, 4, 6, 12]

On teste tous les entiers de 1 à $n$ ; ceux qui divisent $n$ sont rangés dans la liste.

Les compréhensions de listes

Python permet de décrire une liste en une seule ligne, à la manière d'un ensemble défini en mathématiques. Cet outil s'appelle une compréhension de liste ⁴. On l'a déjà croisé dans des ressources de formation pour la seconde, par exemple pour fabriquer une liste de booléens servant de point de départ au crible d'Ératosthène ².

DéfinitionCompréhension de liste

Une compréhension s'écrit :

[expression for variable in parcours]

et on peut y ajouter un filtre :

[expression for variable in parcours if condition]

Le résultat est une nouvelle liste : pour chaque valeur de la variable, retenue par la condition, on range la valeur de l'expression.

ExempleTrois compréhensions

carres = [k**2 for k in range(1, 6)]
# [1, 4, 9, 16, 25]

pairs = [k for k in range(1, 11) if k % 2 == 0]
# [2, 4, 6, 8, 10]

doubles = [2 * x for x in [3, 5, 8]]
# [6, 10, 16]

Tu retrouves en une ligne ce qu'une boucle avec append faisait en trois ou quatre.

MéthodePasser de la boucle à la compréhension

Repère la liste vide initiale, la boucle for et le append.
Ce qui est dans append(...) devient l'expression placée en tête.
La boucle for se recopie telle quelle, à la suite.
S'il y a un if autour du append, il se place à la fin.

Exemple : la boucle

R = []
for k in range(1, 21):
    if k % 5 == 0:
        R.append(k)

devient R = [k for k in range(1, 21) if k % 5 == 0], soit [5, 10, 15, 20].

Listes et fonctions

Une fonction peut prendre une liste en paramètre, et en renvoyer une avec return. C'est le fonctionnement de la plupart des programmes que tu écris en mathématiques.

ExempleUne fonction qui renvoie une liste

def multiples(a, n):
    """Renvoie les n premiers multiples positifs de a."""
    return [a * k for k in range(1, n + 1)]

print(multiples(7, 4))   # affiche [7, 14, 21, 28]

Attention, erreur fréquenteDeux noms, une seule liste

Écrire M = L ne copie pas la liste : les deux noms désignent la même liste. Modifier l'une modifie l'autre.

L = [1, 2, 3]
M = L
M[0] = 99
print(L)   # affiche [99, 2, 3]

Pour obtenir une vraie copie indépendante, écris M = L.copy().

Trois applications mathématiques

Les listes servent à représenter des objets mathématiques : l'ensemble des diviseurs d'un entier, la suite de ses chiffres, la liste des nombres premiers jusqu'à une borne. Les ressources de formation destinées à la seconde proposent des programmes de ce genre, notamment la liste des facteurs premiers d'un entier, les chiffres d'un entier en base 10 et le crible ². Voici une version de chacun, écrite avec les outils de ce cours.

ExempleLes chiffres d'un entier

Pour un entier naturel $n$ , le reste de la division par 10 donne le dernier chiffre, et la division entière par 10 supprime ce chiffre.

def chiffres(n):
    L = []
    while n > 0:
        L.append(n % 10)
        n = n // 10
    return L

print(chiffres(2024))   # affiche [4, 2, 0, 2]

Les chiffres sortent de droite à gauche. Pour les avoir dans l'ordre de lecture, on peut écrire L.insert(0, n % 10) à la place de append, ou retourner la liste avec L.reverse().

Ce programme répond aussi à une question classique de la seconde : pour un entier $n \geq 1$ , le nombre de chiffres est len(chiffres(n)) ¹. Pour 2024, on trouve 4. Attention : chiffres(0) renvoie [], alors que 0 s'écrit avec un chiffre.

ExempleLa décomposition en facteurs premiers

Idée : on cherche des diviseurs de $n$ en commençant par 2. Tant qu'un diviseur convient, on le note dans la liste et on réduit $n$ ; sinon, on passe au candidat suivant.

def facteurs(n):
    resultat = []
    k = 2
    while n != 1:
        if n % k == 0:
            resultat.append(k)
            n = n // k
        else:
            k = k + 1
    return resultat

print(facteurs(60))   # affiche [2, 2, 3, 5]

Suivi pour $n = 60$ : 2 divise 60, on note 2 et $n$ devient 30 ; 2 divise encore 30, on note 2 et $n$ devient 15 ; 2 ne divise pas 15, donc k passe à 3 ; 3 divise 15, on note 3 et $n$ devient 5 ; k passe à 4, puis à 5 ; 5 divise 5, on note 5 et $n$ devient 1, ce qui arrête la boucle. On obtient $60 = 2 \times 2 \times 3 \times 5$ .

Le candidat 4 n'est jamais noté : quand k atteint 4, $n$ ne contient plus aucun facteur 2, donc 4 ne peut pas le diviser.

ExempleLe crible d'Ératosthène

Le crible cherche tous les nombres premiers jusqu'à une borne $n$ . Le principe, tel qu'on le présente en seconde : on écrit les entiers à partir de 2, on entoure 2 et on barre ses multiples ; on entoure le premier nombre non barré, on barre ses multiples, et on recommence ².

En Python, on utilise une liste de booléens : est_premier[i] vaut True tant que i n'est pas barré.

def crible(n):
    est_premier = [False, False] + [True for i in range(n - 1)]
    for i in range(2, n + 1):
        if est_premier[i]:
            for m in range(2 * i, n + 1, i):
                est_premier[m] = False
    return [i for i in range(len(est_premier)) if est_premier[i]]

print(crible(30))
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

La dernière ligne est une compréhension avec filtre : elle garde les indices dont la case contient encore True ². La liste a 10 éléments : il y a donc 10 nombres premiers inférieurs ou égaux à 30.

Erreurs fréquentes et méthode de contrôle

Exercices corrigés

Exercice 1 Moyenne d'une série de notes

★☆☆Environ 8 min

On considère la liste notes = [12, 15, 9, 14].

Écris une boucle qui calcule la somme des éléments de notes.
En déduire la moyenne des notes, en utilisant len(notes).

Indice 1

Initialise une variable somme à 0 avant la boucle.

Indice 2

La moyenne est la somme divisée par le nombre d'éléments.

Voir la correction pas à pas

On crée l'accumulateur : somme = 0.
On parcourt les valeurs : for x in notes: puis somme = somme + x. La variable somme prend les valeurs 12, 27, 36 puis 50.
On calcule le nombre d'éléments : len(notes) vaut 4.
On divise : moyenne = somme / len(notes), soit $\dfrac{50}{4} = 12{,}5$ .

La somme des notes est 50 et leur moyenne est 12,5.

Exercice 2 Somme des carrés pairs

★★☆Environ 10 min

Écris une compréhension de liste qui donne les carrés des entiers pairs de 1 à 10 inclus.
Calcule la somme des éléments de cette liste.

Indice 1

Pour avoir les entiers de 1 à 10 inclus, utilise range(1, 11).

Indice 2

Un entier k est pair quand k % 2 == 0.

Voir la correction pas à pas

On parcourt range(1, 11), qui produit 1, 2, …, 10.
On garde les entiers pairs avec le filtre if k % 2 == 0 : 2, 4, 6, 8, 10.
On écrit la compréhension : [k**2 for k in range(1, 11) if k % 2 == 0]. Elle donne [4, 16, 36, 64, 100].
On additionne : $4 + 16 + 36 + 64 + 100 = 220$ .

La liste est [4, 16, 36, 64, 100] et la somme vaut 220.

Exercice 3 Combien de nombres premiers jusqu'à 30 ?

★★★Environ 15 min

On applique le crible d'Ératosthène aux entiers de 2 à 30 : on barre les multiples de 2, puis ceux de 3, puis ceux de 5.

Pourquoi n'est-il pas nécessaire de barrer les multiples de 7 pour terminer le travail ?
Écris la liste des nombres restants, puis donne leur nombre.

Indice 1

Si un entier composé $m \le 30$ n'a pas de diviseur premier $\le 5$ , que pourrait valoir le plus petit de ses diviseurs premiers ?

Indice 2

Le plus petit diviseur premier $p$ d'un entier composé $m$ vérifie $p^2 \le m$ .

Voir la correction pas à pas

Un entier composé $m \le 30$ a un plus petit diviseur premier $p$ tel que $p^2 \le m \le 30$ . Donc $p \le 5$ , car $7^2 = 49 > 30$ .
Tout composé inférieur ou égal à 30 a donc déjà été barré en tant que multiple de 2, 3 ou 5. Barrer les multiples de 7 n'ajouterait rien : ils ont déjà disparu.
Après le barrage, il reste : 2, 3, 5, 7, 11, 13, 17, 19, 23, 29.
On compte les éléments de la liste : 10.

Il reste la liste [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] : il y a 10 nombres premiers inférieurs ou égaux à 30.

Les questions qu'on se pose

Pourquoi les indices commencent-ils à 0 et pas à 1 ?

C'est la convention de Python, partagée par la plupart des langages de programmation. L'indice mesure le décalage par rapport au début de la liste : le premier élément est à un décalage de 0. Retiens que, pour une liste de $n$ éléments, les indices vont de $0$ à $n-1$ . En cas de doute, fais un petit schéma avec une liste de 3 cases.

Quelle différence entre `for x in L` et `for i in range(len(L))` ?

Dans le premier cas, x est la valeur de l'élément ; dans le second, i est l'indice et on lit l'élément avec L[i]. Utilise la première forme quand tu n'as pas besoin de la position, et la seconde quand tu veux la position, parcourir deux listes en parallèle ou modifier des cases.

Quand utiliser une compréhension plutôt qu'une boucle avec append ?

Quand la liste se décrit simplement : une expression, un parcours, éventuellement un seul filtre. Si tu hésites à relire ta ligne, ou si le calcul demande plusieurs étapes, une boucle classique est préférable. Les deux écritures donnent le même résultat, et on te demande souvent de savoir passer de l'une à l'autre.

Pourquoi mon programme affiche-t-il None ?

Deux causes fréquentes. Soit tu as écrit L = L.append(x) : append ne renvoie rien, donc L devient None. Soit ta fonction n'a pas de return (ou le return est oublié), et Python renvoie alors None par défaut. Vérifie ces deux points d'abord.

Comment tester qu'une fonction qui construit une liste est correcte ?

Choisis un cas dont tu connais la réponse, par exemple facteurs(60) qui doit donner [2, 2, 3, 5], ou crible(30) qui doit donner dix nombres premiers. Teste aussi des cas limites : une valeur très petite, comme facteurs(1), qui doit renvoyer la liste vide. Affiche le résultat avec print et compare avec ta réponse à la main.

Sources

Programme visé : Mathématiques enseignement commun, classe de seconde — Algorithmique et programmation · eduscol.education.gouv.fr

Mathématiques enseignement commun, classe de seconde — Algorithmique et programmation, eduscol.education.gouv.fr. Consulté le 9 novembre 2026.
Formation UPO Python Seconde — Listes — Académie de Lyon, ac-lyon.fr. Consulté le 9 novembre 2026.
Python — Mathématiques — Académie de Lyon, ac-lyon.fr. Consulté le 9 novembre 2026.
Python (langage), Wikipédia. Consulté le 9 novembre 2026.
Python royal, Wikipédia. Consulté le 9 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Les listes en Python : cours de 2de

L'essentiel

Pourquoi utiliser des listes ?

Créer une liste et lire ses éléments

Parcourir une liste avec des boucles

Construire une liste : append et range

Les compréhensions de listes

Listes et fonctions

Trois applications mathématiques

Erreurs fréquentes et méthode de contrôle

Exercices corrigés

Exercice 1 Moyenne d'une série de notes

Exercice 2 Somme des carrés pairs

Exercice 3 Combien de nombres premiers jusqu'à 30 ?

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur