Listes, statistiques et simulations

Une série statistique est une liste ; un échantillon simulé aussi. Ce chapitre met les listes au service des chapitres « Probabilités conditionnelles » et « Variables aléatoires » du manuel : calculer les indicateurs, simuler des expériences aléatoires, observer la fluctuation d'échantillonnage, estimer par Monte-Carlo — et analyser les fréquences des lettres d'un texte, l'algorithme du programme.

4.1 Indicateurs d'une série statistique

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

def variance(L):
    m = moyenne(L)
    return sum([(x - m)**2 for x in L]) / len(L)

def ecart_type(L):
    return variance(L) ** 0.5

notes = [12, 8, 15, 10, 15]
print(moyenne(notes), variance(notes), ecart_type(notes))
# 12.0 7.6 2.756...

Pourquoi calculer les deux ? Parce que la moyenne seule ne distingue pas ces deux séries :

def mediane(L):
    T = sorted(L)              # copie TRIÉE de L (L n'est pas modifiée)
    n = len(T)
    if n % 2 == 1:
        return T[n // 2]                   # valeur centrale
    return (T[n//2 - 1] + T[n//2]) / 2     # moyenne des deux centrales

def etendue(L):
    return max(L) - min(L)

print(mediane([12, 8, 15, 10, 15]))   # 12
print(mediane([12, 8, 15, 10]))       # 11.0

4.2 Loi d'une variable aléatoire : deux listes

Une loi de probabilité se code naturellement par deux listes parallèles — les valeurs et leurs probabilités, appariées par l'indice :

valeurs = [0, 2, 5]
probas  = [0.2, 0.5, 0.3]        # même longueur, somme 1

def esperance(valeurs, probas):
    E = 0
    for i in range(len(valeurs)):
        E += probas[i] * valeurs[i]
    return E

def variance_loi(valeurs, probas):
    E = esperance(valeurs, probas)
    return sum([probas[i] * (valeurs[i] - E)**2 for i in range(len(valeurs))])

print(esperance(valeurs, probas))       # 2.5
print(variance_loi(valeurs, probas))    # 3.25 -> sigma = 1.803

4.3 Simuler une variable aléatoire

from random import random

def simule(valeurs, probas):
    r = random()
    cumul = 0
    for i in range(len(valeurs)):
        cumul += probas[i]
        if r < cumul:              # r est tombé dans le i-ème intervalle
            return valeurs[i]

def echantillon(valeurs, probas, n):
    return [simule(valeurs, probas) for k in range(n)]

E = echantillon([0, 2, 5], [0.2, 0.5, 0.3], 1000)
print(E.count(5) / len(E))   #   0.3 : la fréquence approche la probabilité

Le segment $[0;1[$ découpé aux longueurs des probabilités : le tirage uniforme $r$ tombe dans l'intervalle de la valeur simulée — ici $r\approx 0,56$ donne la valeur $2$.

4.4 Fluctuation d'échantillonnage

def moyenne_echantillon(n):
    return moyenne(echantillon([0, 2, 5], [0.2, 0.5, 0.3], n))

# Une liste de 200 moyennes d'échantillons de taille 100 :
M = [moyenne_echantillon(100) for k in range(200)]
print(min(M), max(M))       # par exemple 1.98 et 3.02 : ça fluctue !

# Proportion des moyennes dans [mu - 2s/rac(n), mu + 2s/rac(n)] :
mu, sigma, n = 2.5, 1.803, 100
seuil = 2 * sigma / n**0.5
p = sum([1 for m in M if abs(m - mu) <= seuil]) / len(M)
print(p)                    #   0.95 : la propriété du cours, vérifiée

Histogramme des $200$ moyennes d'échantillons : elles s'entassent autour de $\mu =2,5$, presque toutes entre $\mu \pm \frac{2\sigma }{\sqrt{n}}$ — la cloche de la fluctuation d'échantillonnage.

4.5 Monte-Carlo, version compréhensions

from random import random

n = 10**6
points = [(random(), random()) for k in range(n)]
pi_estime = 4 * sum([1 for (x, y) in points if x*x + y*y <= 1]) / n
print(pi_estime)      #   3.1418

4.6 Fréquences des lettres d'un texte

L'algorithme du programme — et un cas d'école du comptage par liste : on utilise une liste de $26$ compteurs, indexée par le rang de la lettre dans l'alphabet (ord(c) - ord("a")). Fidèle à la règle « rien que des listes ».

def frequences_lettres(texte):
    compteurs = [0] * 26                # 26 zéros : un par lettre
    total = 0
    for c in texte.lower():
        i = ord(c) - ord("a")           # rang de la lettre : a -> 0, z -> 25
        if 0 <= i < 26:                 # on ignore espaces, chiffres, accents
            compteurs[i] += 1
            total += 1
    return [compteurs[i] / total for i in range(26)]

francais = frequences_lettres("le petit prince demanda dessine moi un mouton")
lettre_max = francais.index(max(francais))
print(chr(ord("a") + lettre_max))       # 'e' : la lettre reine du français

Profil des fréquences du français (grands textes) : le « e » culmine à $17\%$. En anglais, il ne dépasse pas $13\%$ et le « t » monte à $9\%$ : comparer les profils permet d'identifier la langue d'un texte — et de casser les chiffrements par simple substitution, comme le fit Al-Kindi au IX^e siècle.

4.7 Exercices d'entraînement

Difficulté : ★ facile   ★ moyen   ★ plus difficile.

def centrer_reduire(L):
    m, s = moyenne(L), ecart_type(L)
    return [(x - m) / s for x in L]

Z = centrer_reduire([7, 12, 9, 15, 9, 11])
print(moyenne(Z), ecart_type(Z))   #   0.0 (à 1e-16 près) et 1.0

from random import randint

S = [randint(1, 6) + randint(1, 6) for k in range(10000)]
freq = [S.count(s) / len(S) for s in range(2, 13)]
print(freq[5])    # fréquence de 7 :   0.166 (théorie : 6/36 = 0.1667)

valeurs = [8, 0, -2]            # gains algébriques (recette - mise)
probas  = [0.1, 0.3, 0.6]
print(esperance(valeurs, probas))                     # -0.4
G = echantillon(valeurs, probas, 10000)
print(moyenne(G))                                     #   -0.4

for n in [25, 100, 400]:
    M = [moyenne_echantillon(n) for k in range(200)]
    print(n, ecart_type(M))
# 25    0.36
# 100   0.18
# 400   0.09

exact = sum([1 for a in range(1, 7) for b in range(1, 7)
             for c in range(1, 7) if a + b + c > 12]) / 216

n = 10**5
freq = sum([1 for k in range(n)
            if randint(1,6) + randint(1,6) + randint(1,6) > 12]) / n
print(freq)     #   0.259
print(exact)    # 56/216 = 0.2592...

def lettre_frequente(texte):
    F = frequences_lettres(texte)
    return chr(ord("a") + F.index(max(F)))