Mathématiques — Première

Listes Python et expérimentations — Maths Première (chapitre 11)

Name: Listes Python et expérimentations — Maths Première (chapitre 11)
Availability: InStock
Author: ProfBot

Listes en Python (extension, compréhension, parcours), simulation d'une variable aléatoire, moyenne d'un échantillon et fluctuation en 2 sigma sur racine de…

Par ProfBot

Listes et expérimentations

Chapitre 11 — Algorithmique · Première, spécialité mathématiques

Une moyenne calculée sur $10$ lancers de dé peut valoir $2{,}8$ ou $4{,}3$ ; sur $10\,000$ lancers, elle vaudra presque à coup sûr entre $3{,}45$ et $3{,}55$. Ce chapitre fait voir ce phénomène, en le simulant. C'est aussi lui qui donne l'outil informatique du programme — la liste — et une première mesure de l'incertitude d'un sondage.

Au programme officiel (programme 2026, applicable à la rentrée 2026-2027). Notion de liste : générer une liste (en extension, par ajouts successifs, en compréhension), manipuler ses éléments et leurs indices, la parcourir, itérer sur ses éléments. Expérimentations : simuler une variable aléatoire ; écrire une fonction renvoyant la moyenne d'un échantillon de taille $n$ ; étudier la distance entre cette moyenne et l'espérance ; simuler $N$ échantillons et calculer la proportion des cas où l'écart entre la moyenne observée $m$ et $\mu$ est inférieur ou égal à $\dfrac{2\sigma}{\sqrt n}$.
Aucune démonstration n'est exigible : ce chapitre est expérimental.

1. Les listes

Définition. Une liste est une collection ordonnée d'éléments, repérés par leur indice. En Python, on la note entre crochets.

Une liste de six cases avec leurs valeurs et leurs indices de 0 à 5.

Les indices commencent à ZÉRO. Une liste de $6$ éléments a donc pour indices $0, 1, 2, 3, 4, 5$ — et L[6] provoque une erreur. C'est de très loin la première cause de bug. Retenir : le dernier indice est len(L) - 1, ou plus simplement L[-1], qui désigne toujours le dernier élément.

Les trois façons de construire une liste

1. En extension — on écrit les éléments un par un :


L = [7, 3, 9, 4, 1, 8]

2. Par ajouts successifs — on part du vide et on remplit :


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

3. En compréhension — on décrit la liste au lieu de la construire :


carres = [k * k for k in range(1, 7)]              # même résultat, une ligne
pairs  = [k for k in range(20) if k % 2 == 0]      # avec une condition

La compréhension se lit comme une définition d'ensemble. [k*k for k in range(1,7)] est la traduction directe de $\{k^2 \mid k \in \{1,\dots,6\}\}$, et la condition après if joue le rôle du « tel que ». C'est le lien que le programme demande de faire entre listes et vocabulaire ensembliste.

Manipuler et parcourir


L = [7, 3, 9, 4, 1, 8]

len(L)          # 6   — le nombre d'éléments
L[0]            # 7   — le premier
L[-1]           # 8   — le dernier
L[2] = 99       # remplace le troisième élément
L.append(5)     # ajoute 5 à la fin
L.remove(3)     # supprime la PREMIÈRE occurrence de la valeur 3
sum(L), max(L), min(L)

Deux façons de parcourir — et il faut savoir choisir :


for x in L:              # itérer sur les ÉLÉMENTS
    print(x)

for i in range(len(L)):  # parcourir par les INDICES
    print(i, L[i])

La première est plus lisible et suffit dans la plupart des cas. La seconde est nécessaire dès qu'on a besoin de la position, ou qu'on veut modifier la liste en place.

2. Simuler une variable aléatoire

Le module random fournit le hasard :


from random import randint, random

randint(1, 6)     # un entier au hasard entre 1 et 6 INCLUS — un lancer de dé
random()          # un décimal au hasard dans [0 ; 1[

Attention à la borne. randint(a, b) inclut les deux bornes, contrairement à range(a, b) qui exclut $b$. Pour simuler un dé, c'est bien randint(1, 6).

Simuler une loi quelconque. Pour une variable prenant les valeurs $x_i$ avec les probabilités $p_i$, on tire un réel dans $[0\,;1[$ et on regarde dans quel « segment » il tombe :


def simuler(valeurs, probas):
    """Tire une valeur au hasard selon la loi donnée."""
    u = random()
    cumul = 0
    for x, p in zip(valeurs, probas):
        cumul += p
        if u < cumul:
            return x
    return valeurs[-1]        # filet de sécurité contre les arrondis

3. Moyenne d'un échantillon

Définition. Un échantillon de taille $n$ est une liste de $n$ résultats obtenus en répétant $n$ fois la même expérience, de façon indépendante. Sa moyenne est $m = \frac{x_1 + x_2 + \cdots + x_n}{n}.$


def moyenne_echantillon(n):
    """Moyenne de n lancers de dé."""
    echantillon = [randint(1, 6) for _ in range(n)]   # en compréhension
    return sum(echantillon) / n

Ne pas confondre $m$ et $\mu$. L'espérance $\mu = E(X)$ est un nombre théorique, fixe, calculé sur la loi — pour un dé, $\mu = 3{,}5$. La moyenne $m$ est un nombre observé, qui change à chaque simulation. Toute la question est de savoir de combien $m$ peut s'écarter de $\mu$.

4. La fluctuation en $\dfrac{2\sigma}{\sqrt n}$

C'est le cœur expérimental du chapitre. On simule $N$ échantillons de taille $n$, on calcule la moyenne de chacun, et on regarde comment ces $N$ moyennes se répartissent autour de $\mu$.

Trois histogrammes de moyennes d'échantillons pour n = 10, 100 et 1000, de plus en plus resserrés.

Les $2000$ moyennes se resserrent autour de $\mu = 3{,}5$ quand $n$ grandit. La bande colorée a pour demi-largeur $\dfrac{2\sigma}{\sqrt n}$.

Ce que l'on observe. La proportion des échantillons pour lesquels $|m - \mu| \leqslant \frac{2\sigma}{\sqrt n}$ est d'environ $95\,\%$, et cela quelle que soit la taille $n$ (pourvu qu'elle ne soit pas trop petite). Ce qui change avec $n$, ce n'est pas cette proportion : c'est la largeur de l'intervalle, qui diminue en $\dfrac{1}{\sqrt n}$.


def proportion_dans_intervalle(N, n, mu, sigma):
    """Proportion des N échantillons de taille n dont la moyenne
       est à moins de 2*sigma/racine(n) de mu."""
    marge = 2 * sigma / (n ** 0.5)
    dedans = 0
    for _ in range(N):
        m = moyenne_echantillon(n)
        if abs(m - mu) <= marge:
            dedans += 1
    return dedans / N

La règle du $\sqrt n$ et ce qu'elle coûte. Pour diviser l'incertitude par $2$, il faut quadrupler l'échantillon ; pour la diviser par $10$, le multiplier par $100$. C'est pourquoi un sondage sur $1\,000$ personnes annonce une marge d'environ $3$ points, et qu'il faudrait interroger $100\,000$ personnes pour descendre à $0{,}3$ point. La précision coûte cher, et de plus en plus cher.

5. La méthode de Monte-Carlo

Le programme la cite comme exemple d'algorithme. Le principe : estimer une aire en comptant des points tirés au hasard.

Un nuage de points aléatoires dans un carré, ceux situés sous la parabole étant colorés.

On tire $N$ points au hasard dans le carré $[0\,;1] \times [0\,;1]$, d'aire $1$, et l'on compte ceux qui tombent sous la courbe. La proportion obtenue estime l'aire cherchée.


def aire_sous_parabole(N):
    """Estime l'aire sous y = x² sur [0 ; 1] — valeur exacte : 1/3."""
    dedans = 0
    for _ in range(N):
        x, y = random(), random()
        if y <= x * x:
            dedans += 1
    return dedans / N

Estimer $\pi$. Même idée avec un quart de disque de rayon 1, d'aire $\dfrac\pi4$ : la proportion de points vérifiant $x^2+y^2 \leqslant 1$ tend vers $\dfrac\pi4$, donc $4 \times$ cette proportion estime $\pi$.

Une méthode lente mais universelle. Monte-Carlo converge en $\dfrac{1}{\sqrt N}$ : pour gagner une décimale, il faut cent fois plus de points. C'est très inefficace pour estimer $\pi$, qu'on sait calculer bien mieux — mais c'est parfois la seule méthode disponible pour des problèmes que le calcul n'atteint pas, en physique ou en finance.

6. Exercices corrigés

Exercice 1 — Lire une liste

Soit L = [4, 8, 15, 16, 23, 42]. Que valent len(L), L[0], L[3], L[-1] et L[6] ?

Correction. len(L) vaut $6$ · L[0] vaut $4$ · L[3] vaut $16$ (le quatrième élément) · L[-1] vaut $42$ · L[6] provoque une erreur : les indices valides s'arrêtent à $5$.

Exercice 2 — Compréhension

Écrire en compréhension : a. les cubes des entiers de 1 à 10 ; b. les multiples de 3 inférieurs à 30 ; c. les carrés pairs des entiers de 1 à 20.

Correction.


a = [k**3 for k in range(1, 11)]
b = [k for k in range(30) if k % 3 == 0]
c = [k**2 for k in range(1, 21) if (k**2) % 2 == 0]

Pour c, on peut simplifier : un carré est pair si et seulement si l'entier l'est, donc [k**2 for k in range(2, 21, 2)] donne le même résultat.

Exercice 3 — Écrire une fonction

Écrire une fonction qui renvoie la moyenne d'une liste de nombres, sans utiliser sum.

Correction.


def moyenne(L):
    total = 0
    for x in L:             # on itère sur les ÉLÉMENTS
        total = total + x
    return total / len(L)

Attention : si la liste est vide, len(L) vaut $0$ et la division échoue. Une version robuste testerait ce cas.

Exercice 4 — Simuler et prévoir

On lance un dé équilibré $n = 100$ fois. On rappelle $\mu = 3{,}5$ et $\sigma = \sqrt{35/12} \approx 1{,}708$. a. Calculer $\dfrac{2\sigma}{\sqrt n}$. b. Dans quel intervalle la moyenne observée a-t-elle environ $95\,\%$ de chances de tomber ?

Correction. a. $\dfrac{2 \times 1{,}708}{\sqrt{100}} = \dfrac{3{,}416}{10} \approx 0{,}342$.

b. L'intervalle est $[3{,}5 - 0{,}342\,;\,3{,}5 + 0{,}342]$, soit environ $[3{,}158\,;\,3{,}842].$

Interprétation : sur 100 lancers, une moyenne de $3{,}2$ ou de $3{,}8$ est parfaitement banale ; une moyenne de $4{,}5$ serait en revanche très suspecte et ferait douter de l'équilibre du dé.

Exercice 5 — L'effet de la taille

Reprendre l'exercice précédent avec $n = 10\,000$. Que devient l'intervalle ?

Correction. $\frac{2\sigma}{\sqrt{10\,000}} = \frac{3{,}416}{100} \approx 0{,}034,$ d'où l'intervalle $[3{,}466\,;\,3{,}534]$.

En multipliant l'échantillon par $100$, on a divisé la marge par $\sqrt{100} = 10$. La moyenne observée est désormais contrainte à deux centièmes près — c'est exactement la loi des grands nombres, vue expérimentalement.

Exercice 6 — Monte-Carlo

On tire $10\,000$ points au hasard dans le carré unité et l'on en trouve $7\,854$ à l'intérieur du quart de disque. Quelle estimation de $\pi$ obtient-on ?

Correction. La proportion vaut $\dfrac{7854}{10000} = 0{,}7854$, et elle estime $\dfrac\pi4$. Donc $\pi \approx 4 \times 0{,}7854 = 3{,}1416.$

Remarque : le résultat est ici remarquablement proche de $\pi \approx 3{,}14159$ — c'est une coïncidence favorable. Avec $10\,000$ points, la précision typique est de l'ordre de $\dfrac{1}{\sqrt{10\,000}} = 0{,}01$, soit deux décimales seulement.

À retenir

Les listes

Geste	Écriture
en extension	`L = [7, 3, 9]`
par ajouts	`L.append(x)` dans une boucle
en compréhension	`[k*k for k in range(1,7) if ...]`
longueur, dernier	`len(L)`, `L[-1]`
itérer / indexer	`for x in L` / `for i in range(len(L))`

Les indices commencent à 0 : le dernier est len(L) - 1.

Simulation : randint(a, b) inclut les deux bornes.

La fluctuation d'échantillonnage $|m - \mu| \leqslant \frac{2\sigma}{\sqrt n} \qquad\text{dans environ } 95\,\% \text{ des échantillons.}$ La proportion ne dépend pas de $n$ ; c'est la largeur de l'intervalle qui diminue, en $\dfrac{1}{\sqrt n}$.

Ne pas confondre $\mu$ (théorique, fixe) et $m$ (observée, variable).

Dernier chapitre : le vocabulaire ensembliste, la logique et les automatismes — la boîte à outils de toute l'année.

Le programme complet de première

Algèbre

Analyse

Géométrie

Probabilités et statistiques

Parties transversales

← Chapitre 10 · Variables aléatoires réelles  |  Chapitre 12 · Logique, ensembles et automatismes →

Tous les cours · coursDeLion · La chaîne YouTube