Python SciPy statsmodels en pratique : le code et les commandes qui comptent vraiment

Python SciPy statsmodels : l'essentiel en un article — vrai code, schémas et étapes concrètes, extraits d'un cours de 37 leçons.

Python SciPy statsmodels en pratique : le code et les commandes qui comptent vraiment

Pas de théorie interminable ici : on ouvre le terminal et on pratique. Voici l'essentiel de Python SciPy statsmodels, extrait directement d'un cours complet de 37 leçons — avec du vrai code que tu peux copier-coller maintenant.

tl;dr
  • Introduction et Installation
  • Rappel NumPy pour SciPy
  • Decouvrir SciPy
  • Statistiques descriptives avec scipy.stats
  • Tests statistiques avec SciPy
~$ cat ./parcours.md # Python SciPy statsmodels — 10 chapitres
01
Introduction et Installation
→ Présentation du cours→ Installer Python et les bibliothèques+ 1 autres leçons
02
Rappel NumPy pour SciPy
→ Les tableaux NumPy, la brique fondamentale→ Ce qu’on peut faire avec un tableau NumPy+ 1 autres leçons
03
Découvrir SciPy
→ C’est quoi SciPy et à quoi ça sert ?→ Organisation des modules scipy.stats+ 1 autres leçons
04
Statistiques descriptives avec scipy.stats
→ Moyenne, médiane et mode→ Variance, écart-type et dispersion+ 1 autres leçons
05
Tests statistiques avec SciPy
→ Introduction aux tests statistiques et à la p-valeur→ Test t de Student — comparer deux moyennes+ 2 autres leçons
06
Introduction à Statsmodels
→ C’est quoi Statsmodels et en quoi diffère-t-il de SciPy ?→ Charger des données et explorer les jeux intégrés+ 1 autres leçons
07
Régression linéaire avec Statsmodels
→ Théorie de la régression linéaire expliquée simplement→ Régression linéaire simple avec Statsmodels+ 2 autres leçons
08
Régression logistique avec Statsmodels
→ Théorie de la régression logistique→ Régression logistique en pratique avec Statsmodels+ 1 autres leçons
🏁
Projet final (+ 2 chapitres en chemin)
→ Tu repars avec un projet concret et démontrable

Prévoir le futur avec ARIMA

NOTECe que vous allez apprendre — ARIMA est un modèle qui apprend des tendances du passé pour prédire le futur. Nous allons voir comment ca marche, comment le configurer, et comment l’utiliser pour générer une prévision.

Ce qu’on va voir dans cette leçon

C’est quoi ARIMA, en termes simples ?

ARIMA est un algorithme de prévision. Il regarde les valeurs du passé et essaie de déduire ce qui va se passer dans le futur.

TIPAnalogie — Imaginez un météorologue. Pour prévoir la température de demain, il regarde la température des derniers jours. Si les 3 derniers jours étaient 18, 20, 22 degrés (tendance à la hausse), il prédira probablement 24 demain. ARIMA fait pareil, mais en utilisant des mathématiques précises.

Le nom complet est Auto-Regressive Integrated Moving Average. C’est un nom compliqué, mais le concept est simple : le modèle se base sur les valeurs passées et les erreurs de prévision passées pour estimer la prochaine valeur.

Les 3 paramètres de ARIMA : p, d, q

On écrit ARIMA(p, d, q). Chaque lettre a un rôle précis.

ParamètreSignificationExemple simple
p Combien de valeurs passées on utilise pour prédire p=2 : on regarde les 2 derniers mois
d Combien de fois on transforme la série pour la stabiliser d=1 : la plupart du temps, d=1 suffit
q Combien d’erreurs passées on utilise pour corriger la prévision q=1 : on tient compte de la dernière erreur
TIPConseil pour débutant — Commencez toujours par ARIMA(1, 1, 1). C’est le réglage de base qui fonctionne bien dans la majorité des cas. Vous pourrez tester d’autres valeurs plus tard si besoin.
NOTEA quoi sert le d ? — La plupart des séries réelles ont une tendance (les ventes augmentent chaque année, par exemple). ARIMA a besoin que la série soit « stable » (sans tendance) pour fonctionner. Le paramètre d transforme la série pour la rendre stable. d=1 signifie qu’on calcule les différences entre valeurs consécutives.

Construire le modèle ARIMA pas à pas

On reprend notre série de ventes mensuelles sur 4 ans. On va utiliser les 38 premiers mois pour entraîner le modèle, et les 10 derniers mois pour vérifier si les prévisions sont bonnes.

output
import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA

# --- Recreer la serie de ventes mensuelles ---
np.random.seed(42)
dates = pd.date_range(start="2020-01", periods=48, freq="ME")
tendance = np.arange(48) * 1.0
mois = dates.month
saisonnalite = 10 * np.sin(2 * np.pi * (mois - 3) / 12)
bruit = np.random.normal(0, 3, 48)
ventes = 100 + tendance + saisonnalite + bruit
serie = pd.Series(ventes, index=dates, name="Ventes")

# --- Diviser : 38 mois pour apprendre, 10 mois pour tester ---
train = serie.iloc[:38]   # donnees d'entrainement
test  = serie.iloc[38:]   # donnees de test (le futur connu)

print(f"Entrainement : {len(train)} mois")
print(f"Test         : {len(test)} mois")
output
# --- Creer et ajuster le modele ---
# order=(p, d, q) = (1, 1, 1) : reglage de base
modele = ARIMA(train, order=(1, 1, 1))
resultat = modele.fit()

# Afficher un resume court
print(f"AIC du modele : {resultat.aic:.2f}")
print("Modele ajuste avec succes !")
TIPAIC = Akaike Information Criterion. C’est un score qui mesure la qualité du modèle. Plus il est bas, mieux c’est. On l’utilise pour comparer plusieurs modèles ARIMA entre eux.

Générer une prévision

Maintenant qu’on a entraîné le modèle, on lui demande de prévoir les 10 prochains mois.

output
# Generer une prevision pour 10 mois
prevision = resultat.forecast(steps=10)

# Comparer prevision vs valeurs reelles
comparaison = pd.DataFrame({
    "Reel"    : test.values.round(1),
    "Prevision": prevision.values.round(1),
    "Erreur"  : (test.values - prevision.values).round(1)
}, index=test.index)

print(comparaison)
NOTEComment lire ce tableau ?
  • Reel : les vraies ventes de ces mois-là (ce qu’on a caché au modèle pendant l’entrainement)
  • Prevision : ce que le modèle ARIMA a prédit
  • Erreur : la différence. Une erreur proche de 0 est bonne. Une grande erreur signifie que la prévision était mauvaise.

Mesurer la qualité de la prévision

Pour savoir si notre modèle prévoit bien, on calcule l’erreur moyenne absolue (MAE). C’est simplement la moyenne des erreurs, sans tenir compte du signe (positif ou négatif).

output
mae = np.abs(test.values - prevision.values).mean()
print(f"Erreur moyenne absolue (MAE) : {mae:.1f} unites")
print(f"Moyenne des ventes reelles   : {test.mean():.1f} unites")
print(f"Erreur relative              : {mae / test.mean() * 100:.1f}%")
TIPInterprétation — Le modèle se trompe en moyenne de 9.1 unites, sur des ventes moyennes de 141. Ca représente une erreur de 6.4%. Pour un modèle de base ARIMA(1,1,1), c’est acceptable. On pourrait améliorer en testant d’autres valeurs de p et q.

Prévoir le futur au-delà des données disponibles

Dans la vraie vie, vous n’avez pas de données de test à comparer. Vous voulez juste prévoir les prochains mois.

Premier script SciPy

NOTEObjectif — Écrire et exécuter votre tout premier script utilisant SciPy. Vous allez calculer des statistiques simples sur un jeu de données factice, voir comment SciPy s’utilise, et vous assurer que tout fonctionne avant d’aller plus loin.

Objectifs pédagogiques

TIPÀ l’issue de ce module — Vous aurez exécuté votre premier script SciPy, vous comprendrez la structure d’un script d’analyse et vous serez à l’aise pour passer aux chapitres suivants.

La structure d’un script d’analyse type

Tout script d’analyse de données en Python suit un schéma similaire. Apprendre ce schéma dès maintenant vous aidera dans tous les chapitres suivants.

Schéma général

Scénario : analyser les notes d’un cours

Vous êtes professeur. Vous avez les notes de 20 étudiants sur 100. Vous voulez comprendre :

Étape 1 : les imports

La première chose à faire dans tout script est d’importer les bibliothèques. Voici pourquoi on les importe avec des alias :

output
import numpy as np                   # np est plus court a ecrire que numpy
from scipy import stats              # on importe uniquement le module stats de SciPy
import matplotlib.pyplot as plt      # plt est l'alias standard pour tracer des graphiques
NOTEPourquoi from scipy import stats et non import scipy ? — SciPy est divisé en sous-modules. Importer seulement stats est plus efficace car on ne charge que ce dont on a besoin. On écrit ensuite stats.mean() plutôt que scipy.stats.mean().

Étape 2 : créer les données

output
notes = np.array([
    72, 85, 91, 63, 78, 55, 88, 94, 70, 82,
    66, 79, 87, 61, 90, 75, 83, 68, 77, 95
])

print("Nombre d'etudiants :", len(notes))
print("Notes              :", notes)
TIPnp.array() — Cette fonction crée un tableau NumPy à partir d’une liste Python. Un tableau NumPy ressemble à une liste Python, mais il est beaucoup plus puissant pour les calculs mathématiques. SciPy travaille toujours avec des tableaux NumPy.

Étape 3 : calculer les statistiques avec scipy.stats

output
moyenne = np.mean(notes)
mediane = np.median(notes)
ecart_type = np.std(notes)
minimum = np.min(notes)
maximum = np.max(notes)

print(f"Moyenne    : {moyenne:.2f}")
print(f"Mediane    : {mediane:.2f}")
print(f"Ecart-type : {ecart_type:.2f}")
print(f"Minimum    : {minimum}")
print(f"Maximum    : {maximum}")

Étape 4 : utiliser scipy.stats pour aller plus loin

NumPy calcule les statistiques de base. SciPy va plus loin en ajoutant des mesures comme l’asymmétrie (skewness) et l’aplatissement (kurtosis), qui indiquent la forme de la distribution.

output
asymetrie = stats.skew(notes)
aplatissement = stats.kurtosis(notes)
description = stats.describe(notes)

print(f"Asymetrie (skewness)   : {asymetrie:.4f}")
print(f"Aplatissement (kurt)   : {aplatissement:.4f}")
print()
print("Description complete par scipy.stats.describe() :")
print(description)

Étape 5 : interpréter les résultats

StatistiqueValeurCe que ça signifie
Moyenne77.95En moyenne, les étudiants ont presque 78/100
Médiane78.50La moitié des étudiants a moins de 78.5 et l’autre moitié plus
Écart-type11.32Les notes varient d’environ 11 points autour de la moyenne
Asymmétrie (-0.25)LégèreLa distribution est presque symétrique (légère concentration vers les notes élevées)
Aplatissement (-0.88)NégatifDistribution un peu plus plate que la loi normale (platykurtique)
NOTEMoyenne vs médiane — La moyenne (77.95) et la médiane (78.50) sont très proches ici. Cela indique qu’il n’y a pas de valeurs extrêmes qui "tirent" la moyenne vers le haut ou le bas. Quand la moyenne et la médiane sont très différentes, cela signale souvent des valeurs aberrantes (outliers).

Étape 6 : visualiser (bonus)

output
plt.figure(figsize=(8, 4))
plt.hist(notes, bins=8, color='steelblue', edgecolor='white', alpha=0.8)
plt.axvline(moyenne, color='red', linestyle='--', label=f'Moyenne ({moyenne:.1f})')
plt.axvline(mediane, color='orange', linestyle='-', label=f'Mediane ({mediane:.1f})')
plt.xlabel("Note sur 100")
plt.ylabel("Nombre d'etudiants")
plt.title("Distribution des notes de la classe")
plt.legend()
plt.tight_layout()
plt.show()
TIPplt.axvline() — Cette fonction trace une ligne verticale sur le graphique. C’est utile pour marquer la moyenne ou la médiane sur un histogramme.

Ce qu’on peut faire avec un tableau NumPy

NOTECe que vous allez apprendre — Comment lire une valeur précise dans un tableau, comment garder seulement certaines valeurs, et comment faire des calculs sur tout un tableau d’un seul coup.

Ce qu’on va voir dans cette leçon

Lire une valeur précise dans un tableau

Imaginez que votre tableau est une rangée de cases numérotées. La première case est numérotée 0, pas 1. C’est une convention en Python. La deuxième case est 1, la troisième est 2, etc.

TIPAnalogie — C’est comme les étages d’un immeuble en Europe : le rez-de-chaussée est l’étage 0. Le premier étage est 1. En Python, on compte pareil.

On peut aussi compter depuis la fin avec des nombres négatifs. -1 donne le dernier élément, -2 l’avant-dernier, etc.

output
import numpy as np

# Un tableau de 7 temperatures de la semaine
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])
#                          [0]   [1]   [2]   [3]   [4]   [5]   [6]

print( temperatures[0] )   # 18.5  -> lundi (1ere valeur)
print( temperatures[2] )   # 19.8  -> mercredi (3e valeur)
print( temperatures[-1] )  # 23.4  -> dimanche (derniere valeur)
print( temperatures[-2] )  # 17.2  -> samedi (avant-derniere)

Sélectionner plusieurs valeurs à la suite

Si vous voulez prendre un morceau du tableau, utilisez la notation debut:fin. Attention : la valeur de fin est exclue. Si vous écrivez [1:4], vous obtenez les cases 1, 2 et 3, mais pas la case 4.

TIPAnalogie — C’est comme couper une baguette de pain. Si vous dites « donne-moi du morceau 1 au morceau 4 », le boulanger vous donne les morceaux 1, 2, 3. Le morceau 4 reste au magasin.
output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Les 3 premiers jours (lundi, mardi, mercredi)
print( temperatures[:3] )     # debut omis = depuis le debut

# Du mardi au vendredi (index 1 a 4, 4 exclu)
print( temperatures[1:4] )

# Les 2 derniers jours
print( temperatures[-2:] )    # fin omise = jusqu'a la fin

# Un jour sur deux (lundi, mercredi, vendredi, dimanche)
print( temperatures[::2] )

Garder seulement les valeurs qui vérifient une condition

C’est une des choses les plus puissantes de NumPy. Vous pouvez dire « donne-moi seulement les températures supérieures à 21 degrés » et NumPy fait la sélection automatiquement.

Voici comment ca marche en 2 étapes :

output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Etape 1 : quel jour fait-il plus de 21 degres ?
masque = temperatures > 21
print("Masque :", masque)
# True la ou c'est superieur a 21, False sinon

# Etape 2 : garder seulement ces valeurs
print("Jours > 21 degres :", temperatures[masque])

# On peut aussi faire les deux etapes en une seule ligne :
print("Jours < 20 degres :", temperatures[temperatures < 20])
NOTEComment lire le masque ? — Le masque a la même taille que le tableau. Pour chaque valeur du tableau, il dit True (oui, cette valeur vérifie la condition) ou False (non). NumPy ne garde ensuite que les positions marquées True.

Faire des calculs mathématiques sur tout le tableau

NumPy propose des fonctions mathématiques qui s’appliquent à chaque élément en même temps. Pas besoin de boucle. Vous écrivez une seule ligne et NumPy fait le calcul sur toutes les valeurs.

output
data = np.array([4.0, 9.0, 16.0, 25.0])

# np.sqrt = racine carree de chaque valeur
print("Racine carree :", np.sqrt(data))

# np.log = logarithme naturel de chaque valeur
print("Logarithme    :", np.round(np.log(data), 2))

# np.abs = valeur absolue (enleve le signe negatif)
nombres = np.array([-3, 5, -7, 2])
print("Valeur absolue:", np.abs(nombres))

Calculer des statistiques sur tout le tableau

Ces fonctions résument un tableau en un seul nombre :

output
ventes = np.array([1200, 850, 1500, 970, 1100, 1350, 780])

print("Total de la semaine :", np.sum(ventes))
print("Moyenne journaliere :", np.mean(ventes).round(1))
print("Journee la plus haute :", np.max(ventes))
print("Journee la plus basse :", np.min(ventes))

# cumsum : total cumulatif jour par jour
print("Cumul jour par jour  :", np.cumsum(ventes))
TIPA quoi sert cumsum ? — cumsum signifie « somme cumulative ». Chaque valeur affichée est le total depuis le début. Ici : lundi = 1200, lundi+mardi = 2050, lundi+mardi+mercredi = 3550, etc. Utile pour suivre un chiffre d’affaires qui s’accumule.

Appliquer un calcul sur toutes les valeurs en même temps

En Python normal, si vous voulez ajouter 10% à chaque prix d’une liste, vous écrivez une boucle. Avec NumPy, vous n’en avez pas besoin. Vous écrivez l’opération une seule fois et elle s’applique à toutes les valeurs. C’est ce qu’on appelle le broadcasting.

TIPAnalogie — Imaginez une année de hausse des prix. Tous les prix de votre liste sont augmentés de 20%. Avec NumPy, vous multipliez le tableau entier par 1.20 en une seule ligne. Sans NumPy, vous auriez dû écrire une boucle qui parcourt chaque prix un par un.
va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet Python SciPy statsmodels (11 chapitres, 37 leçons, exercices corrigés et projet final) t'emmène jusqu'au bout.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Combien de temps pour apprendre Python SciPy statsmodels ?
Avec une progression structurée (11 chapitres, 37 leçons courtes et pratiques), on atteint un niveau opérationnel en quelques semaines à raison de 30 à 60 minutes par jour. L'important est de pratiquer chaque notion immédiatement.
Faut-il des prérequis ?
Des bases en informatique suffisent. Si tu sais utiliser un terminal et lire du code simple, tu es prêt.
Par où commencer concrètement ?
Reproduis les commandes de cet article, puis suis le cours complet Python SciPy statsmodels : il enchaîne les 37 leçons dans l'ordre, avec exercices et projet final.

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.