Guide pratique du module statistics de Python

Liens rapides

• Qu’est-ce que le module statistics de Python ?
• Statistiques descriptives
• Régression et corrélation
• La loi normale
• NumPy, SciPy et alternatives

Qu’est-ce que le module statistics de Python ?

Le module statistics est un module standard de Python pour effectuer des calculs statistiques simples. Il fait partie de la bibliothèque standard et est donc disponible dans toute installation Python. Pour l’utiliser dans un script ou une session interactive, il suffit de l’importer :

import statistics

En session interactive (interpréteur Python, IPython, Jupyter), il est courant d’importer directement quelques fonctions dans l’espace de noms courant pour éviter de préfixer statistics. systématiquement. Les exemples de cet article supposent ce type d’import direct quand c’est pertinent.

Important : importer des symboles dans l’espace de noms global facilite l’expérimentation, mais évitez d’écraser des fonctions intégrées dans des scripts de production.

Statistiques descriptives

Les statistiques descriptives résument les caractéristiques principales d’un jeu de données : tendance centrale (moyenne, médiane, mode) et dispersion (variance, écart-type, quantiles).

Exemple simple — calcul de la moyenne :

from statistics import mean, fmean, geometric_mean, harmonic_mean, median, mode, stdev, pstdev, variance, pvariance, quantiles

a = [4, 4, 3, 6]
print(mean(a))        # => 4.6

Notes rapides sur les fonctions de moyenne :

• mean : moyenne arithmétique standard (somme / nombre d’éléments). Résultat ici : 4.6.
• fmean : calcule la moyenne en convertissant les valeurs en float. Pratique pour des données mixtes ou pour de meilleures performances numériques.
• geometric_mean : moyenne géométrique, utile pour compenser les taux de croissance (produit des valeurs, racine n-ième).
• harmonic_mean : moyenne harmonique, adaptée aux moyennes de taux (par ex. vitesses moyennes sur distances égales).

Exemples de moyennes pondérées et spécialisées :

# moyenne pondérée (exemple)
from statistics import fmean
weights = [1, 2, 3, 4]
print(fmean(a, weights))  # exemple, résultat ici : 4.5

# moyenne géométrique
from statistics import geometric_mean
print(geometric_mean(a))

# moyenne harmonique
from statistics import harmonic_mean
print(harmonic_mean(a))   # résultat ici : 4.0

Médiane et mode :

print(median(a))  # => 4
print(mode(a))    # => 4 (valeur la plus fréquente)

Mesures de dispersion : variance et écart-type

• variance / pvariance : variance d’échantillon ou de population
• stdev / pstdev : écart-type d’échantillon ou de population

print(stdev(a))   # écart-type d'échantillon, ~1.26
print(pstdev(a))  # écart-type de population
print(variance(a))

Quantiles, minimum et maximum :

print(quantiles(a))  # quartiles par défaut : [Q1, Q2(médiane), Q3]
print(min(a), max(a))

Quand utiliser ces fonctions :

• Analyse rapide en exploration de données (EDA) ou prototypage.
• Calculs pédagogiques et vérification de petites séries.

Contre-exemples (quand ces fonctions ne suffisent pas) :

• Jeux de données massifs (millions de lignes) où les performances mémoire et vitesse comptent.
• Calculs matriciels, transformations vectorisées ou algèbre linéaire avancée.
• Régression multivariée complexe ou tests statistiques avancés.

Conseil pratique : commencez avec statistics pour des essais rapides, puis migrez vers NumPy/Pandas/SciPy pour les workflows réels.

Régression et corrélation

La régression linéaire simple et le coefficient de corrélation sont disponibles pour des cas à deux variables.

from statistics import linear_regression, correlation
x = [1, 2, 3, 4, 5]
y = [5, 7, 9, 11, 13]

slope, intercept = linear_regression(x, y)
print(slope, intercept)   # => 2, 3
print(correlation(x, y))  # => 1.0 (corrélation parfaite)

Ce que fait linear_regression :

• Calcule la droite y = m*x + b par moindres carrés ordinaires (OLS) pour deux variables.
• Retourne la pente (m) et l’ordonnée à l’origine (b).

Limitations :

• Uniquement la régression linéaire simple (une variable indépendante).
• Ne trace pas de graphiques ni ne fournit d’informations avancées (p-valeurs, intervalles de confiance, diagnostics).

Alternatives pour besoins avancés :

• statsmodels : régressions avec diagnostics, p-valeurs, modèles GLM.
• scikit-learn : apprentissage supervisé, régressions régulières (Ridge, Lasso), pipeline ML.
• seaborn / matplotlib : visualisations (nuages de points, droite ajustée).
• pingouin : tests statistiques axés recherche en sciences sociales.

Mini-playbook pour une régression :

1. Explorer les données, visualiser le nuage de points.
2. Vérifier l’hypothèse linéaire (relation approximativement linéaire).
3. Si multivarié ou besoin d’inférence statistique, utiliser statsmodels.
4. Pour prédiction en production, utiliser scikit-learn et pipelines.

La loi normale

La loi normale (courbe en cloche) modélise beaucoup de phénomènes naturels et est utile pour estimer des probabilités continues. Python fournit NormalDist pour travailler avec cette distribution.

Exemple basé sur des données (valeurs citées) : moyenne masculine = 175.1 cm, taille d’échantillon n = 2690, erreur standard (SE) = 0.3.

Calcul de l’écart-type à partir de l’erreur standard :

import math
se = 0.3
n = 2690
std = math.sqrt(n) * se
print(std)  # ≈ 15.56

Création d’un objet NormalDist et calcul d’une probabilité :

from statistics import NormalDist
men_height = NormalDist(mu=175.1, sigma=std)
# Pourcentage d'hommes entre 160 et 180 cm
prob = men_height.cdf(180) - men_height.cdf(160)
print(prob)  # ≈ 0.45 -> environ 45%

Remarques importantes :

• Le calcul ci-dessus transforme une erreur standard en écart-type de la population en multipliant par sqrt(n). Vérifiez toujours la définition de l’erreur standard fournie par votre source.
• NormalDist propose des méthodes utiles : pdf(x) densité, cdf(x) probabilité cumulée, inv_cdf(p) quantile inverse.

Exemple rapide :

print(men_height.pdf(175.1))  # densité au point moyen
print(men_height.inv_cdf(0.975))  # quantile 97.5%

NumPy, SciPy et autres : quand migrer

Le module statistics est excellent pour des calculs rapides et l’apprentissage. Toutefois, pour des projets sérieux ou des jeux de données conséquents, les bibliothèques scientifiques offrent plus de puissance et de flexibilité.

Tableau comparatif succinct :

Quand préférer statistics :

• Vous effectuez des calculs ponctuels ou pédagogiques.
• Vous êtes en mode interactif et voulez une API simple.

Quand préférer NumPy/SciPy/Pandas :

• Données volumineuses (performances et mémoire).
• Besoin de vectorisation et d’algèbre linéaire.
• Modèles statistiques avancés, tests et diagnostics.

Boîte à outils et fiches pratiques

Fiche rapide (cheat sheet) — fonctions clés du module statistics :

• Moyennes : mean, fmean, geometric_mean, harmonic_mean
• Tendance centrale : median, mode
• Dispersion : variance, pvariance, stdev, pstdev
• Quantiles : quantiles
• Régression / corrélation : linear_regression, correlation
• Loi normale : NormalDist

Exemples de snippets prêts à l’emploi :

# moyenne et dispersion
from statistics import mean, stdev
vals = [10, 12, 9, 11]
print(f"Moyenne: {mean(vals):.2f}, écart-type: {stdev(vals):.2f}")

# régression simple
from statistics import linear_regression
slope, intercept = linear_regression([1,2,3], [2,4,6])
print(slope, intercept)

# loi normale
from statistics import NormalDist
nd = NormalDist(0,1)
print(nd.cdf(1.96))  # probabilité cumulée pour 1.96

Checklist par rôle

• Étudiant / Débutant : tester statistics pour comprendre les concepts, exécuter exemples en notebook.
• Analyste de données : commencer par statistics pour des vérifications rapides, migrer vers pandas/numpy pour EDA et pipeline.
• Ingénieur logiciel : n’utiliser statistics que pour utilitaires légers ; privilégier numpy/scipy pour la performance et la robustesse.

Mini-méthodologie pour choisir une bibliothèque

1. Taille des données : si < quelques dizaines de milliers d’éléments et calculs simples → statistics.
2. Besoin de vectorisation / matrices → NumPy/Pandas.
3. Inférence statistique (p-valeurs, intervalles) → SciPy / statsmodels.
4. Production et ML → scikit-learn.

Decision tree (aide au choix) :

flowchart TD
  A[Démarrer] --> B{Données volumineuses ?}
  B -- Oui --> C[Utiliser NumPy / Pandas]
  B -- Non --> D{Besoin d'inférence ?}
  D -- Oui --> E[Utiliser SciPy / statsmodels]
  D -- Non --> F[statistics pour prototypage rapide]

Important : n’oubliez pas la validation des données en entrée (valeurs manquantes, NaN, types) avant de calculer des statistiques.

Cas limites et pièges courants

• Valeurs manquantes : statistics lève souvent une erreur si la liste contient None ou NaN. Nettoyez les données avant.
• Échantillons très petits : la variance d’échantillon peut être instable.
• Types mixtes (str + int) : convertissez ou filtrez avant d’appeler les fonctions.
• Rounding et précision : pour de grandes sommes ou nombres très grands, préférez fmean et NumPy pour une meilleure stabilité numérique.

Sécurité, confidentialité et bonnes pratiques

• Si vous manipulez des données personnelles (taille, poids, âge), appliquez les règles de confidentialité et anonymisez/agrégez avant publication.
• Pour des calculs reproduisibles, conservez les versions des bibliothèques (requirements.txt) et ajoutez des tests unitaires pour vos fonctions statistiques.

Résumé et recommandations

• Le module statistics est excellent pour apprendre, prototyper et effectuer des calculs rapides en session interactive.
• Pour des analyses sérieuses sur de gros volumes, ou pour des modèles et diagnostics avancés, migrez vers NumPy, Pandas, SciPy, statsmodels et scikit-learn selon le besoin.
• Validez toujours vos hypothèses (distribution, outliers, taille d’échantillon) et nettoyez les données avant d’appliquer des fonctions statistiques.

Notes finales : commencez par statistics si vous découvrez la statistique en Python, mais gardez en tête la feuille de route de migration vers des bibliothèques plus spécialisées pour la production et les analyses avancées.