Mathématiques · Seconde
Listes en Python : exercices corrigés de seconde
Publié le 9 novembre 2026 · Mis à jour le 9 novembre 2026 · Signaler une erreur
L'essentiel
- Une liste s'écrit entre crochets, ses cases sont numérotées à partir de 0 et
len(L)donne le nombre d'éléments. - Pour lire tous les éléments, on écrit
for x in L; pour avoir aussi la position, on écritfor i in range(len(L)). - Pour construire une liste, on part de
[]et on ajoute avecappend, ou on utilise une compréhension de listes. - Pour retrouver le résultat d'un programme, simule-le à la main avec un tableau des valeurs prises par chaque variable.
Comment utiliser ces exercices
Python est un langage de programmation conçu pour qu'on y entre facilement : sa syntaxe reste simple et lisible4. En seconde, les listes servent à ranger plusieurs valeurs sous un même nom : des notes, des diviseurs, des chiffres, des facteurs premiers. Les exercices ci-dessous t'entraînent à lire ce qu'un programme produit, puis à en écrire toi-même.
Les exercices sont classés par difficulté croissante, du niveau 1 (lecture d'une liste) au niveau 3 (programmes plus longs, parfois avec une boucle non bornée). Pour chacun, cherche d'abord seul avec une feuille et un crayon. Ouvre ensuite les indices, un par un. La correction ne vient qu'en dernier, et elle te montre une démarche, pas seulement un résultat.
Rappel des gestes sur les listes
Pièges à surveiller avant de commencer
Les exercices
Exercice 1 Lire les cases d'une liste
On exécute le programme suivant.
L = [4, 8, 15, 16, 23, 42]
x = L[2] + L[5]
Quelle est la valeur de x à la fin ?
Indice 1
Écris sous chaque valeur de la liste son indice, en commençant par 0.
Indice 2
Combien d'éléments y a-t-il dans la liste ? Le dernier indice vaut cette taille moins 1.
Voir la correction pas à pas
On numérote les cases :
L[0] = 4,L[1] = 8,L[2] = 15,L[3] = 16,L[4] = 23,L[5] = 42.La case d'indice 2 contient 15, car on a compté 0, 1, puis 2.
La liste a 6 éléments, donc son dernier indice est 5 : la case
L[5]contient 42.On additionne : .
À la fin, x vaut 57. Retiens que L[2] désigne le troisième élément de la liste, et que l'indice du dernier élément est len(L) - 1.
Exercice 2 Calculer une moyenne de notes
Voici un programme qui parcourt une liste de notes.
notes = [12, 15, 9, 18, 11]
s = 0
for n in notes:
s = s + n
moyenne = s / len(notes)
Quelle est la valeur de moyenne à la fin ?
Indice 1
Suis la valeur de s après chaque tour de boucle.
Indice 2
len(notes) donne le nombre de notes, c'est-à-dire le diviseur de la moyenne.
Voir la correction pas à pas
Avant la boucle,
svaut 0.Tour 1 :
n = 12, doncs = 0 + 12 = 12.Tour 2 :
n = 15, doncs = 12 + 15 = 27.Tour 3 :
n = 9, doncs = 27 + 9 = 36.Tour 4 :
n = 18, doncs = 36 + 18 = 54.Tour 5 :
n = 11, doncs = 54 + 11 = 65.La liste contient 5 notes, donc
len(notes)vaut 5.On calcule (Python affiche
13.0, car la division/renvoie toujours un nombre décimal).
La moyenne vaut 13. Le motif « somme initialisée à 0, puis ajout de chaque élément » se retrouve dans de nombreux exercices ; Python propose aussi la fonction sum, mais savoir écrire la boucle reste utile.
Exercice 3 Compter les valeurs supérieures ou égales à 10
On exécute ce programme.
L = [7, 12, 10, 3, 15, 9, 10]
compteur = 0
for x in L:
if x >= 10:
compteur = compteur + 1
Quelle est la valeur de compteur à la fin ?
Indice 1
Le compteur n'augmente que si la condition x >= 10 est vraie.
Indice 2
Attention : la valeur 10 vérifie la condition, car elle est « supérieure ou égale » à 10.
Voir la correction pas à pas
Au départ,
compteur = 0.x = 7: la condition est fausse, le compteur reste à 0.x = 12: la condition est vraie, le compteur passe à 1.x = 10: la condition est vraie (10 est égal à 10), le compteur passe à 2.x = 3: fausse, le compteur reste à 2.x = 15: vraie, le compteur passe à 3.x = 9: fausse, le compteur reste à 3.x = 10: vraie, le compteur passe à 4.
Le compteur vaut 4. Si on avait écrit x > 10, les deux valeurs 10 n'auraient pas été comptées et le résultat aurait été 2 : le choix entre > et >= change la réponse.
Exercice 4 Indice du premier maximum
On cherche la position du plus grand élément d'une liste.
T = [3, 17, 8, 21, 5, 21, 14]
imax = 0
for i in range(1, len(T)):
if T[i] > T[imax]:
imax = i
Quelle est la valeur de imax à la fin ?
Indice 1
Ici imax mémorise un indice, pas une valeur : le plus grand élément rencontré est T[imax].
Indice 2
La comparaison est stricte (>) : que se passe-t-il quand on retrouve une valeur égale au maximum actuel ?
Voir la correction pas à pas
Au départ,
imax = 0, donc le maximum provisoire estT[0] = 3.i = 1:T[1] = 17 > 3, doncimax = 1.i = 2:T[2] = 8, et est faux,imaxreste 1.i = 3:T[3] = 21 > 17, doncimax = 3.i = 4:T[4] = 5, et est faux,imaxreste 3.i = 5:T[5] = 21, et est faux (comparaison stricte),imaxreste 3.i = 6:T[6] = 14, et est faux,imaxreste 3.
À la fin, imax vaut 3, et T[imax] vaut 21. La comparaison stricte garde la première position du maximum. Avec >=, on aurait obtenu 5, la position de la seconde valeur 21.
Exercice 5 Construire la liste des carrés
On construit une liste avec une boucle.
C = []
for k in range(1, 7):
C.append(k * k)
s = 0
for c in C:
s = s + c
Écris la liste C obtenue, puis donne la valeur finale de s.
Indice 1
Que vaut range(1, 7) ? La borne 7 est-elle atteinte ?
Indice 2
C démarre vide. Chaque tour ajoute un élément à la fin.
Voir la correction pas à pas
range(1, 7)fournit les entiers 1, 2, 3, 4, 5, 6. La borne 7 est exclue.La liste
Cdémarre à[].Les tours successifs ajoutent , , , , et .
On obtient
C = [1, 4, 9, 16, 25, 36], qui contient 6 éléments.La seconde boucle additionne tous les éléments : , puis , puis , puis , puis .
La liste est [1, 4, 9, 16, 25, 36] et s vaut 91. La première boucle peut s'écrire en une ligne avec une compréhension : C = [k * k for k in range(1, 7)].
Exercice 6 Lire une compréhension de listes
On définit une liste par compréhension.
M = [k for k in range(50) if k % 3 == 0]
Combien d'éléments la liste M contient-elle ? Donne la valeur de len(M).
Indice 1
k % 3 == 0 signifie que le reste de la division de k par 3 est nul, donc que k est un multiple de 3.
Indice 2
Quelles sont les valeurs de k parcourues par range(50) ? Le nombre 0 en fait partie.
Voir la correction pas à pas
range(50)fournit les entiers de 0 à 49.La condition retient les multiples de 3 :
M = [0, 3, 6, 9, ..., 48].Le plus grand multiple de 3 inférieur ou égal à 49 est 48, car et .
Les multiples sont . On compte donc les entiers de 0 à 16, soit éléments.
La liste contient 17 éléments. L'oubli de 0 donne 16, et c'est l'erreur classique : 0 est un multiple de 3 et range(50) commence à 0.
Exercice 7 Somme des diviseurs stricts de 28
On construit la liste des diviseurs d'un entier, 28 exclu.
n = 28
D = []
for d in range(1, n):
if n % d == 0:
D.append(d)
s = 0
for x in D:
s = s + x
Donne la liste D, puis la valeur de s.
Indice 1
n % d == 0 se lit : « d divise n ». Teste les entiers de 1 à 27 un par un, ou cherche les paires de diviseurs dont le produit vaut 28.
Indice 2
range(1, n) s'arrête à 27 : le nombre 28 lui-même n'est jamais testé.
Voir la correction pas à pas
range(1, 28)fournit les entiers de 1 à 27.On retient ceux qui divisent 28. Comme , les diviseurs sont 1, 2, 4, 7, 14 et 28.
Le diviseur 28 n'est pas testé, car la borne de
rangeest exclue. On obtientD = [1, 2, 4, 7, 14].La seconde boucle additionne : , puis , puis , puis .
La liste est [1, 2, 4, 7, 14] et s vaut 28. Retiens la méthode : pour chercher des diviseurs, on teste le reste de la division avec % à l'intérieur d'une boucle, et on garde les valeurs qui conviennent dans une liste.
Exercice 8 Les chiffres d'un entier
On range dans une liste les chiffres de l'entier 4072.
n = 4072
chiffres = []
while n > 0:
chiffres.append(n % 10)
n = n // 10
s = 0
for c in chiffres:
s = s + c
Donne la liste chiffres obtenue, puis la valeur de s. Ici n // 10 est le quotient entier de n par 10.
Indice 1
n % 10 est le reste de la division par 10 : c'est le chiffre des unités de n. n // 10 supprime ce chiffre.
Indice 2
Fais un tableau avec les colonnes n, n % 10 et chiffres, et une ligne par tour.
Voir la correction pas à pas
Tour 1 :
n = 4072. On ajoute4072 % 10 = 2, puisn = 4072 // 10 = 407.Tour 2 :
n = 407. On ajoute7, puisn = 40.Tour 3 :
n = 40. On ajoute0, puisn = 4.Tour 4 :
n = 4. On ajoute4, puisn = 0.Maintenant
n > 0est faux : la boucle s'arrête. On achiffres = [2, 7, 0, 4].La seconde boucle additionne : .
La liste obtenue est [2, 7, 0, 4] : les chiffres sont rangés en commençant par les unités, donc à l'envers de l'écriture habituelle. D'autres programmes préfèrent placer le chiffre de poids fort dans la case d'indice 02 ; il faut alors retourner la liste. La somme des chiffres vaut 13.
Exercice 9 Facteurs premiers de 360
On range dans une liste les facteurs premiers d'un entier, chacun répété autant de fois qu'il apparaît dans la décomposition. Ce type de liste figure dans les ressources de formation de l'académie de Lyon2.
n = 360
F = []
d = 2
while n > 1:
if n % d == 0:
F.append(d)
n = n // d
else:
d = d + 1
Donne la liste F obtenue, puis le nombre d'éléments de cette liste.
Indice 1
Quand d divise n, on ajoute d à la liste et on divise n par d sans augmenter d : le même facteur peut servir plusieurs fois.
Indice 2
Contrôle ton résultat : le produit des éléments de F doit valoir 360.
Voir la correction pas à pas
Départ :
n = 360,d = 2,F = [].360 est divisible par 2 : on ajoute 2, puis
n = 180. Même chose : on ajoute 2,n = 90, puis encore 2,n = 45.Maintenant
n = 45n'est plus divisible par 2 :dpasse à 3.45 est divisible par 3 : on ajoute 3 et
n = 15. Puis on ajoute 3 etn = 5.5 n'est pas divisible par 3, donc
d = 4. 5 n'est pas divisible par 4, doncd = 5.5 est divisible par 5 : on ajoute 5 et
n = 1. La conditionn > 1est fausse, la boucle s'arrête.On obtient
F = [2, 2, 2, 3, 3, 5]. Contrôle : . La liste contient 6 éléments.
La liste est [2, 2, 2, 3, 3, 5], de longueur 6. Elle traduit la décomposition . Le diviseur d ne monte que lorsque la division échoue : c'est ce qui garantit que chaque facteur trouvé est premier.
Les questions qu'on se pose
Pourquoi les indices d'une liste commencent-ils à 0 ?
C'est la convention de Python : l'indice d'un élément indique de combien de cases on se décale par rapport au début de la liste. Le premier élément n'est décalé de rien, son indice est donc 0. Conséquence pratique : une liste de éléments a pour indices , et range(len(L)) parcourt exactement ces indices.
Quand écrire `for x in L` et quand écrire `for i in range(len(L))` ?
Écris for x in L quand tu as seulement besoin des valeurs, par exemple pour une somme ou un compteur. Écris for i in range(len(L)) quand tu as besoin de la position : chercher l'indice d'un maximum, comparer un élément à son voisin, modifier une case avec L[i] = .... Dans le second cas, la valeur s'obtient avec L[i].
Comment vérifier mon résultat quand je simule un programme à la main ?
Fais un tableau avec une ligne par tour de boucle et une colonne par variable. Puis contrôle la taille : une liste construite par append dans une boucle de tours a éléments si l'ajout est inconditionnel. Pour les décompositions, refais le produit des facteurs. Si tu peux exécuter le programme dans un éditeur Python, compare ensuite avec ce qu'il affiche.
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.