insight.Se connecter

Mathématiques · 1re

Algorithmique et programmation — Notion de liste : cours et fiche de révision (Mathématiques, 1re)

Programme officiel, session 2027. Mis à jour le 17 octobre 2026. 7 min de lecture.

Ce que contient ce chapitre

  • Variables, tests et boucles
  • Construire une liste pas à pas
  • Écrire une liste en compréhension
  • Lire et modifier avec les indices
  • Parcourir une liste
  • Découper en fonctions

Algorithmique et programmation : la notion de liste

Un algorithme est une suite d'instructions qui conduit à un résultat. En première, tu consolides variables, conditions, boucles et fonctions, et tu rencontres une seule notion nouvelle : la liste. Une liste range plusieurs valeurs sous un même nom : les termes d'une suite, une série statistique, un tableau de valeurs. À la fin, tu sauras générer une liste, modifier ses éléments grâce à leurs indices, la parcourir et écrire de petites fonctions qui la traitent. Tu peux écrire un algorithme en langage naturel (avec « ← » pour l'affectation) ou en Python ; ce cours privilégie Python.

Variables, types et affectation

Une variable est un nom qui désigne une valeur gardée en mémoire. L'affectation range une valeur dans une variable : on écrit a←5a ← 5 en langage naturel, a = 5 en Python. L'ordinateur calcule d'abord le membre de droite, puis le range dans la variable de gauche. Ce n'est pas une égalité mathématique : a = a + 1 augmente aa de 11.

Chaque valeur a un type : entier (int, 3), flottant (float, 3.0), chaîne de caractères (str, "3"), booléen (bool, True ou False) ou liste (list). Le type change l'effet des opérations : 3 + 4 donne 7, mais "3" + "4" donne "34". En Python, 7 / 2 vaut 3.5, 7 // 2 vaut 3 (quotient entier) et 7 % 2 vaut 1 (reste de la division).

Exemple

Suis les variables ligne par ligne.

a ← 5
b ← a * 2
a ← b - 3

Ligne 1 : a=5a = 5. Ligne 2 : b=5×2=10b = 5 \times 2 = 10. Ligne 3 : a=10−3=7a = 10 - 3 = 7, et bb reste égal à 1010. À la fin, a=7a = 7 et b=10b = 10.

Conditions et boucles

Une instruction conditionnelle (if, else) exécute un bloc seulement si la condition est vraie. Les tests s'écrivent == (égal), != (différent), <, <=, et se combinent avec and, or, not. Une boucle for répète un bloc un nombre connu de fois ; une boucle while le répète tant qu'une condition reste vraie. Le bloc répété est décalé vers la droite : c'est l'indentation, qui fait partie de la syntaxe.

range(n) fournit les entiers 0,1,…,n−10, 1, \dots, n-1 ; range(a, b) fournit a,a+1,…,b−1a, a+1, \dots, b-1. La borne bb est exclue.

Exemple

Calculer la somme des carrés des entiers de 11 à 44.

s = 0
for i in range(1, 5):
    s = s + i * i

Suivi : i=1i = 1 donne s=0+1=1s = 0 + 1 = 1 ; i=2i = 2 donne s=1+4=5s = 1 + 4 = 5 ; i=3i = 3 donne s=5+9=14s = 5 + 9 = 14 ; i=4i = 4 donne s=14+16=30s = 14 + 16 = 30. La boucle s'arrête avant 55 : à la fin, s=30s = 30.

Générer une liste

Une liste est une suite ordonnée d'éléments, notée entre crochets, ses éléments étant séparés par des virgules. L'ordre compte et les répétitions sont permises : [3,1,3][3, 1, 3] et [1,3,3][1, 3, 3] sont deux listes différentes, alors que {3,1,3}\{3, 1, 3\} et {1,3}\{1, 3\} désignent le même ensemble. Trois façons de générer une liste :

  • En extension : on écrit tous les éléments, par exemple L = [2, 5, 8, 11, 14] ; la liste vide s'écrit [].
  • Par ajouts successifs : on part de la liste vide et on ajoute les éléments un à un avec append.
  • En compréhension : on décrit les éléments par une règle, comme on décrit un ensemble par une propriété ; [3 * n + 2 for n in range(5)] correspond à {3n+2∣n∈{0,1,2,3,4}}\{3n + 2 \mid n \in \{0, 1, 2, 3, 4\}\}. Une condition if filtre les éléments.

Exemple

Les trois écritures suivantes génèrent la même liste.

L = [2, 5, 8, 11, 14]

L = []
for n in range(5):
    L.append(3 * n + 2)

L = [3 * n + 2 for n in range(5)]

Pour les deux dernières, on pose les calculs : n=0n = 0 donne 3×0+2=23 \times 0 + 2 = 2 ; n=1n = 1 donne 3×1+2=53 \times 1 + 2 = 5 ; n=2n = 2 donne 88 ; n=3n = 3 donne 1111 ; n=4n = 4 donne 1414. Ce sont les cinq premiers termes de la suite un=3n+2u_n = 3n + 2.

123451015

Sur la figure, l'abscisse est l'indice ii et l'ordonnée la valeur L[i]. Le point d'abscisse 33 a pour ordonnée 1111 : L[3] vaut 1111, c'est le quatrième élément, car on compte à partir de 00.

Avec une condition. [n * n for n in range(1, 8) if n % 2 == 1] correspond à {n2∣n∈{1,…,7}, n impair}\{n^2 \mid n \in \{1, \dots, 7\},\ n \text{ impair}\}. Le test n % 2 == 1 est vrai pour n=1,3,5,7n = 1, 3, 5, 7, donc la liste obtenue est [1,9,25,49][1, 9, 25, 49]. La condition est une proposition vraie ou fausse pour chaque nn : c'est la logique du chapitre précédent.

Indices et manipulation

Chaque élément d'une liste a un indice, c'est-à-dire sa position, et le premier indice est 00. Pour L = [2, 5, 8, 11, 14] : L[0] vaut 22, L[1] vaut 55, L[4] vaut 1414. len(L) donne le nombre d'éléments, ici 55 ; le dernier indice est donc len(L) - 1, soit 44. Demander L[5] provoque une erreur (« index out of range »).

  • L[i] = v remplace l'élément d'indice ii par vv ;
  • L.append(v) ajoute vv à la fin ;
  • L.insert(i, v) insère vv à l'indice ii et décale les suivants ;
  • L.pop(i) supprime l'élément d'indice ii et le renvoie ;
  • L.remove(v) supprime la première occurrence de la valeur vv.

En langage naturel : « ajouter vv à LL », « supprimer de LL l'élément d'indice ii ».

Exemple

On part de L = [2, 5, 8, 11, 14] et on note la liste après chaque instruction.

L.append(17)    # [2, 5, 8, 11, 14, 17]
L[1] = 6        # [2, 6, 8, 11, 14, 17]
L.pop(0)        # [6, 8, 11, 14, 17]
L.remove(11)    # [6, 8, 14, 17]
L.insert(1, 7)  # [6, 7, 8, 14, 17]

À la fin, len(L) vaut 55 et L[2] vaut 88.

Parcourir une liste

Deux façons de parcourir une liste L :

  • par indice : for i in range(len(L)), puis on lit L[i], utile quand la position compte ;
  • par élément : for x in L, la variable xx prend successivement chaque valeur de la liste, dans l'ordre ; c'est plus simple quand la position est inutile.

Exemple

Somme des éléments de L = [6, 7, 8, 14, 17].

total = 0
for x in L:
    total = total + x

Suivi : x=6x = 6 donne 66 ; x=7x = 7 donne 1313 ; x=8x = 8 donne 2121 ; x=14x = 14 donne 3535 ; x=17x = 17 donne 5252. La somme vaut 5252.

Exemple

Liste des éléments pairs de L.

pairs = []
for x in L:
    if x % 2 == 0:
        pairs.append(x)

Le test est vrai pour 66, 88 et 1414 (restes nuls) et faux pour 77 et 1717 : pairs vaut [6,8,14][6, 8, 14]. Parcourir et filtrer revient à écrire en compréhension [x for x in L if x % 2 == 0].

Fonctions et programmation modulaire

Une fonction se définit avec def, reçoit des paramètres et renvoie son résultat avec return. La programmation modulaire découpe une tâche complexe en tâches simples : chaque tâche devient une fonction, que les autres peuvent appeler.

Exemple

Moyenne des cinq premiers termes de la suite un=3n+2u_n = 3n + 2.

def suite(n):
    return [3 * k + 2 for k in range(n)]

def somme(L):
    total = 0
    for x in L:
        total = total + x
    return total

def moyenne(L):
    return somme(L) / len(L)

On évalue moyenne(suite(5)). D'abord suite(5) renvoie [2,5,8,11,14][2, 5, 8, 11, 14]. Ensuite la somme vaut 2+5+8+11+14=402 + 5 + 8 + 11 + 14 = 40 et len vaut 55. Enfin 40/5=840 / 5 = 8 : Python affiche 8.0, car / renvoie un flottant.

Les pièges

  • Compter à partir de 1. L[1] est le deuxième élément ; le dernier indice est len(L) - 1, jamais len(L).
  • Oublier que range exclut la borne. Pour parcourir les entiers de 11 à nn, écris range(1, n + 1).
  • Écrire L = L.append(x). append modifie L et ne renvoie rien : L vaut alors None.
  • Confondre pop et remove. L.pop(3) supprime l'élément d'indice 33 ; L.remove(3) supprime la valeur 33.
  • Supprimer pendant le parcours. Ne retire pas d'éléments de L pendant que for x in L la parcourt : des éléments sont sautés. Construis plutôt une nouvelle liste.
  • Placer return dans la boucle. La fonction s'arrête dès le premier tour ; mets return hors de la boucle, comme dans somme.
  • Confondre = et ==. = affecte une valeur, == teste une égalité.

Ce qu'il faut retenir

  • Une liste est ordonnée, notée entre crochets, et peut contenir des répétitions.
  • On la génère en extension, par ajouts successifs (append) ou en compréhension ([f(n) for n in ... if ...]).
  • Le premier indice est 00 ; le dernier est len(L) - 1.
  • L[i] = v, append, insert, pop(i) et remove(v) modifient la liste ; pop supprime par indice, remove par valeur.
  • range(a, b) va de aa à b−1b - 1.
  • On parcourt une liste par indice (for i in range(len(L))) ou par élément (for x in L).
  • Une condition if dans une compréhension filtre les éléments, comme une propriété dans un ensemble.
  • Une fonction qui traite une liste la reçoit en paramètre et renvoie son résultat avec return.
  • L'affectation se note « ← » en langage naturel et = en Python.

À l'épreuve

Les listes apparaissent dans des exercices sur les suites, la statistique ou les probabilités. Les formulations habituelles : « que contient la liste L après exécution de ce script ? », « quelle valeur renvoie la fonction pour tel argument ? », « écris la ligne manquante du script », « que calcule cette fonction ? ». Le correcteur attend un suivi des variables posé étape par étape (variable de boucle, accumulateur, contenu de la liste), pas seulement le résultat final. Il attend aussi une lecture exacte des indices et des bornes de range, une indentation correcte, et, pour « que calcule cette fonction ? », une phrase qui dit ce qu'elle calcule en général, pas seulement sur un exemple.

À retenir

  • Variables, tests et boucles

    Une affectation calcule le membre de droite puis le range dans la variable de gauche (a ← a + 1).Types : entier, flottant, chaîne, booléen, liste ; en Python, 7 / 2 vaut 3.5, 7 // 2 vaut 3 et 7 % 2 vaut 1.if exécute un bloc si la condition est vraie ; for répète un nombre connu de fois.range(a, b) va de a à b - 1 : la borne b est exclue.
  • Construire une liste pas à pas

    Une liste est ordonnée, notée entre crochets, et accepte les répétitions.En extension : L = [2, 5, 8].Par ajouts successifs : on part de L = [] et une boucle appelle L.append(x).Les éléments d'une suite (u_n) se rangent ainsi dans une liste.
  • Écrire une liste en compréhension

    [expression for n in range(a, b)] décrit les éléments par une règle, comme un ensemble défini par une propriété.Une condition if filtre : [n * n for n in range(1, 8) if n % 2 == 1] donne [1, 9, 25, 49].La condition est une proposition vraie ou fausse pour chaque n.range(a, b) exclut b.
  • Lire et modifier avec les indices

    Le premier indice est 0 ; le dernier est len(L) - 1 ; L[len(L)] provoque une erreur.L[i] = v remplace ; L.append(v) ajoute à la fin ; L.insert(i, v) insère à l'indice i.L.pop(i) supprime par indice ; L.remove(v) supprime la première occurrence de la valeur v.L.append(x) modifie L et ne renvoie rien.
  • Parcourir une liste

    Par indice : for i in range(len(L)) puis L[i], utile quand la position compte.Par élément : for x in L, x prend chaque valeur dans l'ordre.Accumuler (somme, compteur) : initialiser avant la boucle, mettre à jour dans la boucle.Filtrer : if dans la boucle puis append, ou compréhension avec if.
  • Découper en fonctions

    def nom(paramètres): ... return résultat.Programmation modulaire : une fonction par tâche simple, les fonctions s'appellent entre elles.return doit être placé hors de la boucle, sinon la fonction s'arrête au premier tour.moyenne(L) = somme(L) / len(L) : la liste vide est un cas à part.

Teste-toi

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

Question 1 sur 3
On exécute le script suivant, écrit en langage naturel.
a ← 4
b ← a + 3
a ← b * 2
Quelle est la valeur de aa à la fin ?

Correction

Ligne 1 : a=4a = 4. Ligne 2 : b=4+3=7b = 4 + 3 = 7.Ligne 3 : a=7×2=14a = 7 \times 2 = 14 ; bb reste égal à 77.Erreur classique : calculer a×2a \times 2 avec l'ancienne valeur 44 de aa et trouver 88 — la ligne 3 multiplie bb, qui vaut 77.
Question 2 sur 3
On a L = [4, 9, 1, 7]. Quelle expression désigne le dernier élément de L (ici 77), quelle que soit la longueur de la liste ?

Correction

len(L) vaut 44 : les indices vont de 00 à 33.Le dernier indice est 4−1=34 - 1 = 3, donc le dernier élément est L[3], soit 77.Erreur classique : écrire L[len(L)] — le premier indice est 00, donc le dernier est len(L) - 1, et L[len(L)] provoque une erreur.
Question 3 sur 3
Dans une fonction, un return écrit à l'intérieur d'une boucle for laisse la boucle se terminer avant de renvoyer le résultat.

Correction

Dès qu'un return est exécuté, la fonction s'arrête et renvoie sa valeur.À l'intérieur d'une boucle, sans condition, cela se produit dès le premier tour : la boucle ne se termine pas.Erreur classique : placer return dans la boucle — pour qu'elle aille jusqu'au bout, le return doit être hors de la boucle, comme dans somme.

Dans Insight, ce chapitre a 103 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