Aller au contenu
OptiTAB

Maths Terminale · Chapitre 9 · Algorithmique et programmation

Notion de liste

  • 8 parties
  • 6 schémas
  • Lecture ≈ 13 min
  • Conforme au programme
Objectifs

Consolider la notion de liste vue en Première : générer une liste (en extension, par ajouts successifs, en compréhension), manipuler ses éléments et leurs indices (ajouter, supprimer), la parcourir. L'utiliser en Terminale pour les termes d'une suite et un seuil, la simulation d'une loi binomiale, les échantillons et la loi des grands nombres, et le dénombrement des k-uplets et des combinaisons.

Prérequis

Notion de liste de Première ; boucles for et while, instruction if, fonctions. Terminale : suites, loi binomiale, loi des grands nombres, dénombrement.

IRappels : créer et lire une liste

DéfinitionListe

Une liste est une suite finie et ordonnée de valeurs, écrite entre crochets : u = [3, 5, 9, 17, 33]. La liste vide s'écrit [] et len(L) donne le nombre d'éléments de L.

DéfinitionIndices

Le premier élément a l'indice 0 : une liste de n éléments a pour indices 0, 1, …, n−1. L'élément d'indice i s'écrit L[i] ; L[-1] est le dernier élément. L'instruction L[i] = v remplace l'élément d'indice i par v.

La liste u = [3, 5, 9, 17, 33] en cinq cases, avec les indices 0 à 4 au-dessus et les termes u0 à u4 au-dessous : l'indice est le rang
Python
u = [3, 5, 9, 17, 33]
print(len(u))
print(u[0], u[2], u[-1])
u[4] = 34
print(u)
Affichage
5
3 9 33
[3, 5, 9, 17, 34]
MéthodeIndice et rang d'une suite

Si la liste u contient u0, u1, u2, … dans cet ordre, alors u[n] est le terme un : l'indice est le rang. Le dernier terme calculé est u[-1], de rang len(u) - 1.

AttentionIndice hors de la liste

Avec 5 éléments, les indices vont de 0 à 4 : u[5] provoque l'erreur IndexError (« list index out of range » : indice hors de la liste). Le dernier élément est u[-1] ou u[len(u) - 1], jamais u[len(u)].

IIGénérer une liste

1. Trois façons de générer une liste

  • En extension : on écrit toutes les valeurs, [2, 3, 5, 7].
  • Par ajouts successifs : on part d'une liste et une boucle ajoute un élément à chaque tour avec append.
  • En compréhension : [expression for x in …], éventuellement avec un filtre if.
Python
u = [1]
for k in range(5):
    u.append(2 * u[-1] + 1)
print(u)
print([n**2 for n in range(6)])
Affichage
[1, 3, 7, 15, 31, 63]
[0, 1, 4, 9, 16, 25]

La première liste contient les termes u0 à u5 de la suite définie par u0=1 et un+1=2un+1 : chaque terme est calculé à partir du précédent, u[-1]. La seconde est la liste des carrés des entiers de 0 à 5.

2. Listes en compréhension et ensembles

Une liste en compréhension s'écrit comme un ensemble défini par une propriété :

  • l'ensemble {n2∣n∈{0,…,5}} s'écrit [n**2 for n in range(6)] ;
  • l'ensemble {x∈E∣x pair} s'écrit [x for x in E if x%2 == 0].
PropriétéConditions et opérations sur les ensembles

Avec deux propriétés PA et PB qui définissent les parties A et B de E :

  • and (« et ») donne l'intersection A∩B ;
  • or (« ou ») donne la réunion A∪B ;
  • not (« non ») donne le complémentaire A―.
ExempleMultiples de 2 et de 3 entre 1 et 20

E={1,2,…,20} ; A est l'ensemble des multiples de 2 et B celui des multiples de 3. Le test x % 2 == 0 est vrai quand le reste de la division de x par 2 est nul.

Python
E = range(1, 21)
A = [x for x in E if x % 2 == 0]
B = [x for x in E if x % 3 == 0]
I = [x for x in E
     if x % 2 == 0 and x % 3 == 0]
U = [x for x in E
     if x % 2 == 0 or x % 3 == 0]
print(len(A), len(B))
print(I)
print(len(U))
Affichage
10 6
[6, 12, 18]
13

Les éléments de A∩B sont les multiples de 6. On retrouve la formule

card(A∪B)=card(A)+card(B)−card(A∩B)=10+6−3=13
Diagramme de Venn dans E = {1, …, 20} : A les multiples de 2, B les multiples de 3, et leur intersection {6, 12, 18}

IIIAjouter et supprimer des éléments

InstructionEffet sur la liste L
L.append(x)ajoute x à la fin
L.pop()retire le dernier élément et le renvoie
L.pop(i)retire l'élément d'indice i et le renvoie
L.remove(x)supprime la première valeur égale à x
x in Lvaut True si x est dans L
ExempleDeux tirages sans remise

Une urne contient cinq boules numérotées de 1 à 5. La fonction choice(L) du module random choisit un élément de L au hasard ; on le supprime de l'urne avec remove, puis on l'ajoute à la liste des boules tirées. L'instruction seed(2026) fixe la graine du générateur pseudo-aléatoire : le programme donne toujours le même affichage, celui imprimé ici.

Python
from random import choice, seed

seed(2026)
urne = [1, 2, 3, 4, 5]
tirage = []
for k in range(2):
    b = choice(urne)
    urne.remove(b)
    tirage.append(b)
print(tirage)
print(urne)
Affichage
[1, 4]
[2, 3, 5]
Évolution des listes urne et t : au départ [1, 2, 3, 4, 5] et [ ], puis la boule 1 passe de urne à t, puis la boule 4

Une boule tirée n'est plus dans l'urne : le second tirage se fait parmi les 4 boules restantes. C'est un tirage sans remise.

AttentionValeur ou indice

L.remove(x) supprime une valeur, alors que L.pop(i) retire l'élément d'indice i. L.remove(x) provoque une erreur ValueError si x n'est pas dans L : on teste d'abord if x in L:.

IVParcourir une liste

PropriétéDeux parcours
  • Par les éléments : for x in L: ; x prend chaque valeur de L.
  • Par les indices : for i in range(len(L)): ; on utilise L[i]. Ce parcours est nécessaire quand la position compte : rang d'un terme, comparaison de deux termes voisins.
ÉcritureRenvoie
sum(L), len(L)la somme, le nombre d'éléments
max(L), min(L)le plus grand, le plus petit élément
L.count(x)le nombre d'éléments égaux à x
ExempleSomme, moyenne et différences

On parcourt la liste des termes u0 à u5 de la partie II.

Python
u = [1, 3, 7, 15, 31, 63]
s = 0
for x in u:
    s = s + x
print(s, s / len(u))
d = [u[i+1] - u[i]
     for i in range(len(u) - 1)]
print(d)
Affichage
120 20.0
[2, 4, 8, 16, 32]

La liste d des différences un+1−un se parcourt par les indices : avec range(len(u) - 1), l'indice i + 1 reste dans la liste. Tous ses éléments sont positifs : la suite semble croissante.

VListes et suites : termes et seuil

MéthodeSeuil avec une liste

On ajoute les termes tant que le seuil n'est pas dépassé. À la sortie, le dernier terme u[-1] est le premier qui dépasse le seuil, et son rang est len(u) - 1. La liste garde tous les termes : on peut les représenter.

Exempleu0=2, un+1=1,5un et le seuil 100

On cherche le plus petit rang n tel que un>100.

Python
u = [2]
while u[-1] <= 100:
    u.append(1.5 * u[-1])
print(len(u) - 1)
print(round(u[-2], 2))
print(round(u[-1], 2))
Affichage
10
76.89
115.33

Le rang cherché est n=10 : u9≈76,89≤100 et u10≈115,33>100. Par le calcul, la suite étant géométrique :

2×1,5n>100⟺1,5n>50⟺n>ln⁡(50)ln⁡(1,5)≈9,65
Termes de la suite u_n = 2 × 1,5^n et seuil 100 : u9 ≈ 76,89 est en dessous, u10 ≈ 115,33 (en vert) est le premier au-dessus
RemarqueSommes partielles

La liste des sommes Sn=u0+u1+⋯+un se construit aussi par ajouts successifs : S.append(S[-1] + u[n]). Elle permet de conjecturer la limite d'une somme.

VIListes et probabilités

1. Simuler une loi binomiale : effectifs et fréquences

ExempleNombre de « pile » en 6 lancers d'une pièce

X suit la loi binomiale B(6;0,5). On range 10000 valeurs simulées de X dans la liste R, puis on compte les effectifs avec count et on calcule les fréquences en compréhension.

Python
from random import random, seed

seed(2026)
R = []
for i in range(10000):
    x = 0
    for k in range(6):
        if random() < 0.5:
            x = x + 1
    R.append(x)
E = [R.count(k) for k in range(7)]
F = [e / 10000 for e in E]
for k in range(7):
    print(k, E[k], F[k])
Affichage
0 130 0.013
1 930 0.093
2 2328 0.2328
3 3124 0.3124
4 2405 0.2405
5 933 0.0933
6 150 0.015

E[k] est l'effectif de la valeur k et F[k] sa fréquence. Par exemple, la fréquence de X=3 est proche de

P(X=3)=(63)×0,56=2064=0,3125
Diagramme en barres des fréquences de 10 000 valeurs simulées de la loi binomiale B(6 ; 0,5), comparées aux probabilités P(X = k)

2. Échantillons, moyennes et loi des grands nombres

ExempleMoyennes de 5 échantillons de taille 10000

On lance un dé équilibré : l'espérance du numéro obtenu est 3,5. La liste M contient les moyennes de 5 échantillons de 10000 lancers.

Python
from random import randint, seed

seed(2026)
M = []
for j in range(5):
    s = 0
    for i in range(10000):
        s = s + randint(1, 6)
    M.append(s / 10000)
for m in M:
    print(m)
Affichage
3.4689
3.4871
3.4743
3.4951
3.4917

Les moyennes varient d'un échantillon à l'autre, mais restent toutes proches de l'espérance 3,5 : c'est la loi des grands nombres.

VIIListes et dénombrement

1. Les k-uplets : une liste de listes

DéfinitionListe de listes

Les éléments d'une liste peuvent être des listes. Si C est une liste de listes, C[i] est une liste et C[i][j] est l'élément d'indice j de cette liste.

Python
E = ["a", "b", "c"]
C = [[x, y] for x in E for y in E]
print(len(C))
print(C[0], C[1], C[5])
print(C[5][0])
Affichage
9
['a', 'a'] ['a', 'b'] ['b', 'c']
b

Les deux for sont imbriqués : pour chacune des 3 valeurs de x, y prend les 3 valeurs. On obtient les 32=9 couples d'éléments de E ; il y a de même nk k-uplets d'éléments d'un ensemble à n éléments.

Tableau des 9 couples [x, y] d'éléments de {a, b, c} : la diagonale x = y en gris, les 3 couples x < y en vert, qui correspondent aux parties à 2 éléments

2. Arrangements et combinaisons

ConditionCe que l'on obtientNombre
aucunecouples (2-uplets)n2
x != ycouples d'éléments distinctsn(n−1)
x < yparties à 2 éléments(n2)
Python
E = [1, 2, 3, 4]
D = [[x, y] for x in E
     for y in E if x != y]
P = [[x, y] for x in E
     for y in E if x < y]
print(len(D), len(P))
for p in P:
    print(p)
Affichage
12 6
[1, 2]
[1, 3]
[1, 4]
[2, 3]
[2, 4]
[3, 4]

On retrouve 4×3=12 couples d'éléments distincts et (42)=6 parties à 2 éléments. La condition x < y impose l'ordre croissant : chaque partie {x,y} n'est écrite qu'une fois.

RemarquePour aller plus loin

Le module itertools de Python fournit des fonctions qui génèrent directement ces objets (product, permutations, combinations). Elles renvoient des k-uplets d'un autre type que les listes : au lycée, les listes en compréhension suffisent.

VIIIErreurs fréquentes

AttentionLes erreurs classiques
  1. Oublier que le premier indice est 0 : L[len(L)] provoque une erreur IndexError.
  2. Écrire u = u.append(x) : append ne renvoie rien, la liste est perdue.
  3. Se tromper de rang : à partir de [u0], après n ajouts, le dernier terme est un et la liste a n+1 éléments.
  4. Confondre remove(x) (une valeur) et pop(i) (un indice).
  5. Supprimer des éléments d'une liste pendant qu'on la parcourt : certains sont « sautés ». On construit plutôt une nouvelle liste par filtrage.
  6. Confondre or et and dans un filtre : or donne la réunion, and l'intersection.
À retenir
  • Indices de 0 à len(L) - 1 ; L[-1] est le dernier élément ; pour une suite, l'indice est le rang.
  • Générer : en extension, par ajouts successifs (append), en compréhension (avec if, and, or, not).
  • Ajouter : append ; supprimer : pop, remove.
  • Seuil : while u[-1] <= A: puis rang len(u) - 1.
  • Simulation : liste des résultats, effectifs avec count, fréquences en compréhension.
  • Dénombrement : une liste de listes en compréhension, avec deux for et un filtre éventuel, donne les couples (n2), les couples distincts (n(n−1)), les parties à 2 éléments ((n2)).

Fiche de synthèse dans l'onglet Fiches !

Cours lu ? Continue avec :

Plateforme OptiTAB

S’entraîner jusqu’à maîtriser le programme de Terminale

Les 11 exercices corrigés de ce chapitre, le suivi de tes progrès et des révisions guidées.

Découvrir l’abonnement

Cours particuliers

Un prof de maths en Terminale, en ligne

Des séances individuelles avec un professeur, à distance, pour comprendre, combler ses lacunes et préparer les contrôles et le bac.

Réserver un cours particulier