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
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
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.
Le premier élément a l'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.
u = [3, 5, 9, 17, 33]
print(len(u))
print(u[0], u[2], u[-1])
u[4] = 34
print(u)5
3 9 33
[3, 5, 9, 17, 34]Si la liste u contient u[n] est le terme u[-1], de rang len(u) - 1.
Avec 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 filtreif.
u = [1]
for k in range(5):
u.append(2 * u[-1] + 1)
print(u)
print([n**2 for n in range(6)])[1, 3, 7, 15, 31, 63]
[0, 1, 4, 9, 16, 25]La première liste contient les termes u[-1]. La seconde est la liste des carrés des entiers de
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
s'écrit[n**2 for n in range(6)]; - l'ensemble
s'écrit[x for x in E if x%2 == 0].
Avec deux propriétés
and(« et ») donne l'intersection ;or(« ou ») donne la réunion ;not(« non ») donne le complémentaire .
x % 2 == 0 est vrai quand le reste de la division de x par
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))10 6
[6, 12, 18]
13Les éléments de
IIIAjouter et supprimer des éléments
| Instruction | Effet 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 L | vaut True si x est dans L |
Une urne contient cinq boules numérotées de 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.
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)[1, 4]
[2, 3, 5]
Une boule tirée n'est plus dans l'urne : le second tirage se fait parmi les
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
- Par les éléments :
for x in L:;xprend chaque valeur deL. - Par les indices :
for i in range(len(L)):; on utiliseL[i]. Ce parcours est nécessaire quand la position compte : rang d'un terme, comparaison de deux termes voisins.
| Écriture | Renvoie |
|---|---|
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 |
On parcourt la liste des termes
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)120 20.0
[2, 4, 8, 16, 32]La liste d des différences 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
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.
On cherche le plus petit rang
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))10
76.89
115.33Le rang cherché est
La liste des sommes 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
R, puis on compte les effectifs avec count et on calcule les fréquences en compréhension.
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])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.015E[k] est l'effectif de la valeur F[k] sa fréquence. Par exemple, la fréquence de
2. Échantillons, moyennes et loi des grands nombres
On lance un dé équilibré : l'espérance du numéro obtenu est M contient les moyennes de
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)3.4689
3.4871
3.4743
3.4951
3.4917Les moyennes varient d'un échantillon à l'autre, mais restent toutes proches de l'espérance
VIIListes et dénombrement
1. Les -uplets : une liste 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.
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])9
['a', 'a'] ['a', 'b'] ['b', 'c']
bLes deux for sont imbriqués : pour chacune des x, y prend les
2. Arrangements et combinaisons
| Condition | Ce que l'on obtient | Nombre |
|---|---|---|
| aucune | couples (2-uplets) | |
x != y | couples d'éléments distincts | |
x < y | parties à |
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)12 6
[1, 2]
[1, 3]
[1, 4]
[2, 3]
[2, 4]
[3, 4]On retrouve x < y impose l'ordre croissant : chaque partie
Le module itertools de Python fournit des fonctions qui génèrent directement ces objets (product, permutations, combinations). Elles renvoient des
VIIIErreurs fréquentes
- Oublier que le premier indice est
:L[len(L)]provoque une erreurIndexError. - Écrire
u = u.append(x):appendne renvoie rien, la liste est perdue. - Se tromper de rang : à partir de
[u0], après ajouts, le dernier terme est et la liste a éléments. - Confondre
remove(x)(une valeur) etpop(i)(un indice). - 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.
- Confondre
oretanddans un filtre :ordonne la réunion,andl'intersection.
- Indices de
à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 (avecif,and,or,not). - Ajouter :
append; supprimer :pop,remove. - Seuil :
while u[-1] <= A:puis ranglen(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
foret un filtre éventuel, donne les couples ( ), les couples distincts ( ), les parties à éléments ( ).
Fiche de synthèse dans l'onglet Fiches !
Cours lu ? Continue avec :