Cette formation ISHRAQA7 Académie apprend à analyser des données avec Python, des bases du langage jusqu’à un premier modèle de machine learning validé. Les douze chapitres travaillent sur le même cas pratique, l’activité commerciale d’un distributeur d’équipements de bureau, et se terminent par un projet complet dont le rapport est généré par le code.
Parcours
| Niveau | Chapitres |
|---|---|
| Débutant | 1. Premiers pas · 2. Variables et structures · 3. Conditions, boucles, fonctions · 4. Fichiers et environnements |
| Intermédiaire | 5. NumPy · 6. pandas · 7. Nettoyage · 8. Analyse exploratoire · 9. Statistiques descriptives · 10. Matplotlib |
| Avancé | 11. Machine learning avec scikit-learn · 12. Projet final |
Fichiers de la formation
La section de téléchargement propose : le manuel complet, le cahier d’exercices, les corrigés, le guide d’installation et le rapport du projet final en PDF ; les données CSV ; les douze scripts Python ; les carnets Jupyter (corrigés exécutés et exercices à compléter) ; le fichier requirements.txt ; un kit pratique complet (données, scripts, carnets et requirements.txt, sans les PDF).
Niveau 1 · Débutant — Chapitre 1
Python pour l’analyse de données : premiers pas
Python est devenu le langage de référence de l’analyse de données : il est gratuit, lisible et entouré d’un écosystème de bibliothèques spécialisées. Ce chapitre installe l’environnement de travail et exécute un premier script qui lit un vrai fichier de données.
Pourquoi Python pour les données
Un tableur atteint vite ses limites : calculs répétés à la main, fichiers volumineux, traitements difficiles à rejouer. Un script Python décrit chaque étape par écrit ; on le relance sur les données du mois suivant et il produit le même traitement, sans oubli. Les bibliothèques de la formation forment une chaîne cohérente :
| Bibliothèque | Rôle | Chapitres |
|---|---|---|
csv, pathlib, json (standard) |
Lire et écrire des fichiers | 1 à 4 |
| NumPy | Calcul numérique sur des tableaux | 5 |
| pandas | Tables de données : lecture, jointures, agrégations, nettoyage | 6 à 9 |
| Matplotlib | Graphiques | 10 |
| scikit-learn | Apprentissage automatique | 11 |
Installer l’environnement
- Installez Python 3.13 depuis python.org (sous Windows, cochez « Add python.exe to PATH »). Les scripts ont été exécutés avec Python 3.13.
- Décompressez l’archive de la formation dans un dossier court, par exemple
C:\ISHRAQA7\python\. Elle contientdata/,scripts/,notebooks/etrequirements.txt. - Créez l’environnement et installez les bibliothèques ; la procédure détaillée figure au chapitre 4 et dans le guide d’installation.
- Lancez
jupyter labdepuis ce dossier : le navigateur affiche l’arborescence du projet.
Un script (.py) s’exécute d’un bloc : python scripts/ch01.py. Un carnet Jupyter (.ipynb) découpe le même code en cellules exécutées une à une, avec les résultats affichés dessous : c’est l’outil idéal pour explorer. Chaque chapitre est fourni sous les deux formes, plus un carnet d’exercice à compléter.
Un premier script
import csv
from pathlib import Path
DATA = Path('data')
with open(DATA / 'orders.csv', encoding='utf-8', newline='') as f:
orders = list(csv.DictReader(f))
print('Nombre de commandes :', len(orders))
print('Première commande :', orders[0])
csv.DictReader transforme chaque ligne en dictionnaire dont les clés sont les en-têtes de colonnes : orders[0]['status'] donne le statut de la première commande. Le paramètre encoding='utf-8' garantit la lecture correcte des accents et de l’arabe. Le script affiche 3 307 commandes.
Compter par catégorie
by_status = {}
for o in orders:
by_status[o['status']] = by_status.get(o['status'], 0) + 1
print(by_status)
La méthode get(clé, 0) renvoie 0 quand la clé n’existe pas encore : le dictionnaire se remplit au fil de la boucle. Résultat : 3 108 commandes livrées, 117 annulées et 82 retournées.
Le cas pratique de la formation
Tous les chapitres utilisent le même jeu de données : l’activité d’un distributeur d’équipements de bureau en 2024 et 2025 (commandes, lignes de commande, clients, produits, régions, canaux, objectifs), plus un extrait volontairement imparfait pour le nettoyage. Le projet ISHRAQA7 Académie du chapitre 12 réunit toutes les étapes.
Niveau 1 · Débutant — Chapitre 2
Variables, types et structures de données
Avant d’analyser des milliers de lignes, il faut savoir représenter une valeur, une liste de valeurs ou un enregistrement complet. Ce chapitre présente les types de base de Python et les quatre structures de données que l’on utilise en permanence.
Variables et types
product_id = 'P11' # str : texte
quantity = 4 # int : entier
unit_price = 2450.0 # float : nombre décimal
delivered = True # bool : vrai ou faux
print(f'{quantity} × {unit_price:,.2f} = {quantity * unit_price:,.2f}')
Une variable est un nom associé à une valeur ; Python déduit le type de la valeur. La f-string (chaîne précédée de f) insère des expressions entre accolades et les met en forme : :,.2f affiche deux décimales avec un séparateur de milliers.
Convertir ce que l’on lit
Un fichier CSV ne contient que du texte. Avant de calculer, on convertit explicitement : int('4'), float('2450.00'). Une conversion impossible (int('4 pcs')) lève une erreur ValueError : c’est utile, car une donnée inattendue est signalée au lieu d’être silencieusement mal comprise (chapitre 3).
with open(DATA / 'products.csv', encoding='utf-8', newline='') as f:
products = [
{'id': r['product_id'], 'name': r['product_name'], 'cat': r['category_code'],
'price': float(r['list_price']), 'cost': float(r['unit_cost'])}
for r in csv.DictReader(f)
]
Ce bloc est une compréhension de liste : il construit une liste en une expression, à partir de chaque ligne lue. On obtient 30 produits, avec des prix et coûts déjà numériques.
Quatre structures, quatre usages
| Structure | Écriture | Propriété | Usage typique |
|---|---|---|---|
| Liste | [2450.0, 52.0] |
Ordonnée, modifiable | Une série de valeurs |
| Tuple | (52.0, 'P15') |
Ordonné, non modifiable | Un couple ou un enregistrement fixe |
| Ensemble | {'FUR', 'ITE'} |
Sans doublon, sans ordre | Valeurs distinctes, tests d’appartenance |
| Dictionnaire | {'P11': 2450.0} |
Clé → valeur | Recherche rapide par identifiant |
prices = [p['price'] for p in products]
cheapest = min((p['price'], p['id']) for p in products)
categories = {p['cat'] for p in products}
price_of = {p['id']: p['price'] for p in products}
Le produit le moins cher est P15 (52,00 MAD) : min compare les tuples par leur premier élément, le prix. L’ensemble categories contient quatre codes ; le dictionnaire price_of retrouve un prix sans parcourir la liste, comme une RECHERCHEV instantanée.
Trier avec une clé
top5 = sorted(((p['id'], p['price']) for p in products),
key=lambda t: t[1], reverse=True)[:5]
sorted accepte une fonction key qui indique sur quoi trier ; lambda t: t[1] est une petite fonction anonyme qui renvoie le prix. Le découpage [:5] garde les cinq premiers éléments.
Niveau 1 · Débutant — Chapitre 3
Conditions, boucles, fonctions et modules
Un traitement de données combine des décisions (si… alors…), des répétitions (pour chaque ligne…) et des opérations réutilisables. Ce chapitre apprend à écrire des fonctions claires et à s’appuyer sur les modules de la bibliothèque standard.
Fonctions : nommer une règle de gestion
def net_amount(quantity, unit_price, discount_rate=0.0):
"""Montant net d’une ligne : quantité × prix × (1 − remise)."""
return quantity * unit_price * (1 - discount_rate)
print(net_amount(4, 2450.0, 0.05)) # 9310.0
Une fonction porte un nom, reçoit des paramètres et renvoie un résultat avec return. Le paramètre discount_rate=0.0 a une valeur par défaut : on peut l’omettre. La chaîne entre triples guillemets, la docstring, documente la règle. Écrire la règle une seule fois évite d’en avoir trois versions différentes dans le code.
Boucles et dictionnaire de référence
orders = {o['order_id']: o for o in read_csv('orders.csv')}
total_by_status = {}
for l in lines:
status = orders[l['order_id']]['status']
amount = net_amount(int(l['quantity']), float(l['unit_price']), float(l['discount_rate']))
total_by_status[status] = total_by_status.get(status, 0) + amount
Chaque ligne de commande doit retrouver le statut de sa commande. Le dictionnaire orders, indexé par numéro, joue le rôle d’une table de correspondance. Résultat : 28 654 029,30 MAD pour les commandes livrées, 1 090 232,00 MAD pour les annulées et 802 042,15 MAD pour les retournées. Seul le premier montant correspond à des ventes réalisées.
Conditions
def size_class(amount):
if amount >= 10000:
return 'L'
elif amount >= 2000:
return 'M'
return 'S'
Les conditions sont testées dans l’ordre ; la première vraie l’emporte. L’ordre décroissant des seuils est donc essentiel. Sur les 8 472 lignes : 417 grandes, 4 949 moyennes et 3 106 petites.
Modules
Un module regroupe des fonctions prêtes à l’emploi : import statistics donne accès à statistics.mean, median, stdev. La bibliothèque standard contient aussi csv, json, pathlib, datetime. Vos propres fonctions peuvent être rangées dans un fichier outils.py et importées par plusieurs scripts.
Gérer les erreurs
try:
q = int(text)
except ValueError:
q = None # valeur signalée, traitée plus loin
try … except intercepte une erreur prévue. N’interceptez que l’erreur attendue (ValueError), jamais toutes les erreurs : un except: nu masquerait aussi les fautes de frappe dans le code.
Niveau 1 · Débutant — Chapitre 4
Fichiers, dépendances et environnements
Un projet d’analyse doit pouvoir être déplacé, partagé et réinstallé sans surprise. Ce chapitre traite des chemins de fichiers, des formats d’échange, des environnements virtuels et du fichier requirements.txt.
Des chemins portables avec pathlib
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent # dossier du projet
DATA = ROOT / 'data'
for p in sorted(DATA.glob('*.csv')):
print(f'{p.name:<24} {p.stat().st_size:>9,} o')
L’opérateur / assemble les chemins avec le bon séparateur sous Windows, macOS et Linux. Calculer ROOT à partir de l’emplacement du script (__file__) permet de lancer le script depuis n’importe quel dossier. Dans un carnet, où __file__ n’existe pas, les scripts de la formation utilisent le dossier parent du carnet. Le dossier data contient 11 fichiers CSV.
Formats d’échange
| Format | Avantages | Points d’attention |
|---|---|---|
| CSV | Universel, lisible, léger | Séparateur, encodage, décimales, tout est texte |
| JSON | Structures imbriquées, types simples | Moins adapté aux grandes tables |
| Excel (.xlsx) | Lu par tous les métiers | Mises en forme et cellules fusionnées perturbent la lecture |
inventory = [{'file': p.name, 'bytes': p.stat().st_size, 'rows': rows[p.stem]} for p in files]
target = OUT / 'inventaire.json'
target.write_text(json.dumps(inventory, ensure_ascii=False, indent=1), encoding='utf-8')
ensure_ascii=False conserve les accents et l’arabe lisibles dans le fichier. Écrivez toujours en UTF-8 et indiquez-le explicitement à la lecture.
Environnements virtuels et dépendances
Chaque projet doit disposer de son environnement virtuel : un dossier contenant une copie isolée de Python et des bibliothèques du projet. Deux projets peuvent ainsi utiliser des versions différentes de pandas sans conflit.
python -m venv .venv
.venv\Scripts\activate # Windows
source .venv/bin/activate # macOS / Linux
python -m pip install -r requirements.txt
Le fichier requirements.txt de la formation fige les versions avec lesquelles tous les scripts et carnets ont été exécutés : numpy 2.5.3, pandas 3.0.5, matplotlib 3.11.2, scikit-learn 1.9.1, plus JupyterLab. Figer les versions garantit que les résultats du cours se reproduisent à l’identique ; d’autres versions fonctionnent souvent, mais sans garantie.
Vérifier depuis un script
import importlib.metadata as md
for pkg in ['numpy', 'pandas', 'matplotlib', 'scikit-learn']:
print(pkg, md.version(pkg))
Ce contrôle, placé en tête d’un projet, évite de chercher longtemps l’origine d’un écart qui vient d’une version différente.
Niveau 2 · Intermédiaire — Chapitre 5
Calcul numérique avec NumPy
NumPy est le socle du calcul scientifique en Python : il manipule des tableaux de nombres et applique une opération à toutes leurs valeurs d’un coup. pandas et scikit-learn reposent sur lui. Ce chapitre montre comment remplacer les boucles par du calcul vectorisé.
Du dictionnaire au tableau
import numpy as np
qty = np.array([int(r['quantity']) for r in rows])
price = np.array([float(r['unit_price']) for r in rows])
disc = np.array([float(r['discount_rate']) for r in rows])
print(qty.shape, qty.dtype, price.dtype) # (8472,) int64 float64
Un tableau NumPy contient des valeurs d’un seul type, rangées de façon compacte en mémoire. Sa shape donne ses dimensions : ici un vecteur de 8 472 valeurs, une par ligne de commande. Les trois tableaux sont alignés : la position 0 de chacun décrit la même ligne.
Calcul vectorisé
net = qty * price * (1 - disc)
print(net[:5].round(2), round(float(net.sum()), 2))
La multiplication s’applique élément par élément, sans boucle Python : c’est la vectorisation. Le code est plus court et des dizaines de fois plus rapide qu’une boucle sur des milliers de lignes. L’expression 1 - disc illustre la diffusion : le nombre 1 est « étendu » à toute la longueur du tableau. Total de toutes les lignes, tous statuts confondus : 30 546 303,45 MAD.
Masques booléens
big = net > 10_000 # tableau de True / False
print(int(big.sum())) # nombre de lignes concernées
share = net[big].sum() / net.sum()
Une comparaison produit un tableau de booléens, le masque. big.sum() compte les valeurs vraies (417 lignes) et net[big] sélectionne les montants correspondants. Ces grandes lignes, moins de 5 % des lignes, pèsent 24,3 % du montant total : une concentration fréquente en analyse commerciale.
Agrégations et statistiques
| Fonction | Résultat |
|---|---|
a.sum(), a.mean(), a.std() |
Somme, moyenne, écart-type |
a.min(), a.max(), a.argmax() |
Extrêmes et position du maximum |
np.percentile(a, [25, 50, 75]) |
Quartiles |
np.abs, np.round, np.where |
Fonctions élément par élément |
np.where(net > 10_000, 'L', 'S') applique une condition à chaque élément et remplace une boucle avec if/else.
Hasard reproductible
rng = np.random.default_rng(2026)
sim = rng.uniform(0, 0.15, size=1000)
Un générateur créé avec une graine fixe produit toujours la même suite de nombres : une simulation devient reproductible et vérifiable. C’est indispensable pour partager une analyse ou un modèle.
Niveau 2 · Intermédiaire — Chapitre 6
Manipuler des tables avec pandas
pandas est l’outil central de l’analyste Python : il lit des fichiers, sélectionne, filtre, joint et agrège des tables, à la manière d’un tableur programmable. Ce chapitre construit la table de ventes du cas pratique à partir de cinq fichiers.
Lire avec des types maîtrisés
import pandas as pd
orders = pd.read_csv(DATA / 'orders.csv',
dtype={'order_id': str, 'customer_id': str},
parse_dates=['order_date', 'ship_date'])
orders.info()
Un DataFrame est une table : des colonnes nommées, chacune d’un type (une Series). Déclarer les identifiants en texte évite que « 00125 » devienne 125 ; parse_dates convertit les dates. info() affiche le nombre de lignes, les types et les valeurs manquantes. Dimensions : orders (3307, 7), lines (8472, 6).
Sélectionner et filtrer
delivered = orders.loc[orders['status'] == 'delivered',
['order_id', 'order_date', 'customer_id', 'channel_code']]
orders.iloc[:3, :4] # 3 premières lignes, 4 premières colonnes
loc sélectionne par étiquette ou par masque booléen, iloc par position. Le filtre donne 3 108 commandes livrées. Pour combiner des conditions, utilisez & (et), | (ou) et des parenthèses : (orders['status'] == 'delivered') & (orders['channel_code'] == 'WEB').
Joindre des tables
sales = (lines
.merge(orders, on='order_id', how='left', validate='many_to_one')
.merge(products[['product_id', 'product_name', 'category_code', 'unit_cost']],
on='product_id', how='left', validate='many_to_one')
.merge(customers[['customer_id', 'segment_code', 'region_code']],
on='customer_id', how='left', validate='many_to_one')
.merge(regions, on='region_code', how='left', validate='many_to_one'))
sales['net'] = sales['quantity'] * sales['unit_price'] * (1 - sales['discount_rate'])
assert len(sales) == len(lines)
merge est l’équivalent d’une RECHERCHEV, en plus sûr. L’argument validate='many_to_one' vérifie que chaque clé de droite est unique : une clé dupliquée multiplierait les lignes et gonflerait les ventes sans message d’erreur. L’assert final confirme que la table de ventes a autant de lignes que les lignes de commande ; elle compte 20 colonnes.
Agréger
ok = sales[sales['status'] == 'delivered']
by_year = ok.groupby('year')['net'].sum().round(2)
groupby découpe la table par valeur de clé, applique une fonction à chaque groupe et rassemble les résultats, comme un tableau croisé dynamique. Ventes nettes livrées : 2024 = 13 556 438,85 MAD, 2025 = 15 097 590,45 MAD. Pour plusieurs indicateurs à la fois : .agg(net=('net', 'sum'), orders=('order_id', 'nunique')).
Bonnes pratiques
- Enchaîner les opérations entre parenthèses (method chaining) pour lire le traitement de haut en bas.
- Créer une nouvelle variable à chaque étape importante (
ok,y25) plutôt que modifier la table d’origine. - Contrôler chaque jointure : nombre de lignes,
validate, valeurs manquantes après jointure.
Niveau 2 · Intermédiaire — Chapitre 7
Nettoyage et préparation des données
Les données réelles contiennent des doublons, des formats incohérents et des valeurs manquantes. Un nettoyage fiable suit une méthode : diagnostiquer, appliquer des règles validées, vérifier par des contrôles chiffrés. Ce chapitre traite l’extrait imparfait du cas pratique.
Diagnostiquer d’abord
raw = pd.read_csv(DATA / 'orders_raw_export.csv', dtype=str, keep_default_na=False)
diag = {
'duplicates': int(raw.duplicated().sum()),
'dmy_dates': int(raw['order_date'].str.contains('/').sum()),
'city_spaces_or_case': int((raw['city'] != raw['city'].str.strip().str.title()).sum()),
'qty_not_digits': int((~raw['quantity'].str.fullmatch(r'\d+')).sum()),
'comma_prices': int(raw['unit_price'].str.contains(',').sum()),
'missing_customer': int((raw['customer_id'].str.strip() == '').sum()),
}
On lit tout en texte (dtype=str) et sans conversion automatique des vides (keep_default_na=False) : la conversion viendra après le diagnostic. Sur les 1 174 lignes : 28 doublons exacts, 61 dates jj/mm/aaaa, 34 villes mal saisies, 35 quantités non numériques ou négatives, 43 prix avec virgule et 14 clients manquants. Les méthodes .str appliquent les fonctions de texte à toute une colonne.
Des règles validées par le métier
| Défaut | Règle | pandas |
|---|---|---|
| Doublons exacts | Supprimer | drop_duplicates() |
| Deux formats de date | ISO, sinon jj/mm/aaaa | to_datetime(..., errors='coerce') + fillna |
| Espaces et casse | Rogner, majuscule initiale | str.strip().str.title() |
| Quantité « 4 pcs » ou « -2 » | Garder les chiffres | str.replace(r'\D', '', regex=True) |
| Virgule décimale | Remplacer par un point | str.replace(',', '.') |
| Prix saisi ×100 | Diviser si > 10 × prix catalogue | jointure + loc |
| Client manquant | Reprendre celui de la commande | map |
def clean(raw, products, orders):
df = raw.drop_duplicates().copy()
d1 = pd.to_datetime(df['order_date'], format='%Y-%m-%d', errors='coerce')
d2 = pd.to_datetime(df['order_date'], format='%d/%m/%Y', errors='coerce')
df['order_date'] = d1.fillna(d2)
df['city'] = df['city'].str.strip().str.title()
df['quantity'] = df['quantity'].str.replace(r'\D', '', regex=True).astype(int)
df['unit_price'] = df['unit_price'].str.replace(',', '.', regex=False).astype(float)
df['discount_rate'] = df['discount_rate'].astype(float)
df = df.merge(products[['product_id', 'list_price']], on='product_id', how='left', validate='many_to_one')
too_high = df['unit_price'] > 10 * df['list_price']
df.loc[too_high, 'unit_price'] = df.loc[too_high, 'unit_price'] / 100
missing = df['customer_id'].str.strip() == ''
df.loc[missing, 'customer_id'] = df.loc[missing, 'order_id'].map(orders.set_index('order_id')['customer_id'])
df['net'] = df['quantity'] * df['unit_price'] * (1 - df['discount_rate'])
return df.drop(columns='list_price'), int(too_high.sum()), int(missing.sum())
Chaque règle est une décision du service qui connaît les données ; ici, le service commercial a confirmé que les quantités négatives sont des erreurs de signe et que la table des commandes fait foi pour le client. La fonction corrige 4 prix et complète 14 clients. errors='coerce' transforme une date illisible en valeur manquante au lieu d’arrêter le script : on vérifie ensuite qu’il n’en reste aucune.
Valeurs manquantes : décider, pas deviner
Face à une valeur manquante, quatre options : la récupérer depuis une source fiable (le client depuis la commande), la calculer par une règle documentée, exclure la ligne en le signalant, ou la laisser manquante si l’analyse le permet. Remplacer par une moyenne « pour que ça passe » fausse les résultats sans le dire.
Niveau 2 · Intermédiaire — Chapitre 8
Analyse exploratoire des données (EDA)
L’analyse exploratoire consiste à interroger les données avant de conclure : répartitions, croisements, évolutions dans le temps. Elle fait émerger les questions utiles et les anomalies. Ce chapitre construit une table au grain commande et l’explore méthodiquement.
Choisir le grain
La table des lignes répond à « quels produits ? », mais pas à « combien vaut une commande ? ». On construit donc une table au grain commande :
lines['net'] = lines['quantity'] * lines['unit_price'] * (1 - lines['discount_rate'])
per_order = lines.groupby('order_id').agg(net=('net', 'sum'), n_lines=('line_no', 'count')).reset_index()
od = (orders.merge(per_order, on='order_id', how='left', validate='one_to_one')
.merge(customers[['customer_id', 'segment_code']], on='customer_id', how='left')
.merge(segments, on='segment_code', how='left')
.merge(channels, on='channel_code', how='left'))
od['delay'] = (od['ship_date'] - od['order_date']).dt.days
Le délai est calculé par soustraction de dates ; .dt.days extrait le nombre de jours. Il est manquant pour les commandes annulées, jamais expédiées.
Décrire
od.describe() résume les colonnes numériques : effectif, moyenne, écart-type, quartiles. value_counts(normalize=True) donne les proportions d’une variable qualitative. Lisez toujours ces résumés avant d’aller plus loin : un minimum négatif, un maximum démesuré ou un effectif incomplet signalent un problème.
Croiser
pd.crosstab(od['channel_name'], od['status'], normalize='index').round(3)
crosstab compte les combinaisons de deux variables ; normalize='index' transforme les comptes en proportions par ligne, pour comparer des canaux de tailles différentes. pivot_table fait de même avec une valeur agrégée (somme des ventes par région et par mois, par exemple).
Le temps
dl = od[od['status'] == 'delivered'].set_index('order_date')
monthly = dl['net'].resample('MS').sum()
Avec un index de dates, resample('MS') regroupe par mois (« MS » : début de mois) ; la série compte 24 mois. Pour neutraliser la saisonnalité, comparez une période à la même période de l’année précédente, jamais au mois précédent.
Une démarche, pas une liste de graphiques
- Formuler une question précise (« quel canal annule le plus ? »).
- Choisir le grain et la mesure adaptés (commande, taux d’annulation).
- Calculer, puis vérifier l’ordre de grandeur.
- Noter le constat et la question suivante qu’il suscite.
Niveau 2 · Intermédiaire — Chapitre 9
Statistiques descriptives
Une moyenne seule ne décrit pas des données. Les statistiques descriptives résument une distribution par sa tendance centrale, sa dispersion, sa forme et ses relations avec d’autres variables. Ce chapitre les applique au montant des commandes et apprend à les interpréter avec prudence.
Tendance centrale et dispersion
s = v['net'] # commandes livrées 2025
stats = {'mean': s.mean(), 'median': s.median(), 'std': s.std(),
'q1': s.quantile(0.25), 'q3': s.quantile(0.75), 'skew': s.skew()}
| Statistique | Valeur (2025, 1 628 commandes) | Lecture |
|---|---|---|
| Moyenne | 9 274 MAD | Valeur « partagée » si toutes les commandes étaient égales |
| Médiane | 7 132 MAD | La moitié des commandes est en dessous |
| Premier / troisième quartile | 3 739 MAD / 11 989 MAD | La moitié centrale des commandes est entre ces bornes |
| Écart-type | 8 548 MAD | Dispersion autour de la moyenne |
| Coefficient de variation | 0,92 | Écart-type rapporté à la moyenne, sans unité |
| Asymétrie (skewness) | 2,69 | Positive : longue traîne vers les grandes valeurs |
La moyenne dépasse nettement la médiane et l’asymétrie est positive : quelques commandes très importantes tirent la moyenne vers le haut. Pour décrire une commande « typique », la médiane est plus représentative ; pour un chiffre d’affaires total, c’est la somme (donc la moyenne) qui compte.
Valeurs atypiques : la règle de l’IQR
iqr = q3 - q1
upper = q3 + 1.5 * iqr
outliers = v[s > upper]
L’écart interquartile (IQR = 8 250 MAD) mesure la dispersion de la moitié centrale ; il est peu sensible aux extrêmes. Au-dessus de Q3 + 1,5 × IQR (24 363 MAD), une valeur est dite atypique : 87 commandes, qui pèsent 20,6 % des ventes. Atypique ne veut pas dire erroné : ici ce sont de grosses commandes réelles, à analyser plutôt qu’à supprimer.
Corrélation
v['n_lines'].corr(v['net']) # Pearson
v['n_lines'].corr(v['net'], method='spearman') # Spearman (rangs)
Le coefficient de Pearson mesure une relation linéaire, entre −1 et 1 ; celui de Spearman travaille sur les rangs et capte toute relation croissante, en résistant mieux aux valeurs extrêmes. Une corrélation, même forte, ne prouve pas une causalité : deux variables peuvent dépendre d’une troisième.
Comparer des groupes
Pour comparer les canaux ou les années, mettez côte à côte moyenne, médiane et effectif : v.groupby('channel_code')['net'].agg(['mean', 'median', 'count']). Un écart de moyenne porté par quelques commandes exceptionnelles n’a pas le même sens qu’un décalage de toute la distribution.
Niveau 2 · Intermédiaire — Chapitre 10
Visualiser avec Matplotlib
Un bon graphique fait comprendre un résultat en quelques secondes. Matplotlib est la bibliothèque de base de la visualisation en Python. Ce chapitre construit les graphiques essentiels de l’analyse commerciale et les règles qui les rendent lisibles.
Figure et axes
import matplotlib.pyplot as plt
m = sales.pivot_table(index='month', columns='year', values='net', aggfunc='sum') / 1000
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(m.index, m[2025], color='#10263A', marker='o', label='2025')
ax.plot(m.index, m[2024], color='#9AA8B5', linestyle='--', label='2024')
ax.set_title('Ventes nettes mensuelles (milliers de MAD)')
ax.set_xticks(range(1, 13))
ax.legend(frameon=False)
ax.spines[['top', 'right']].set_visible(False)
fig.savefig(OUT / 'fig_monthly.png', dpi=150)
La figure est la page ; les axes (ax) sont la zone de tracé. Travailler avec ax plutôt qu’avec les fonctions globales permet de contrôler chaque graphique d’une planche. Diviser par 1 000 et l’indiquer dans le titre rend les axes lisibles. La couleur forte est réservée à l’année étudiée, l’année de comparaison reste grise.
Quel graphique pour quelle question ?
| Question | Graphique | Matplotlib |
|---|---|---|
| Évolution dans le temps | Courbe | ax.plot |
| Comparaison de catégories | Barres horizontales triées | ax.barh |
| Distribution d’une variable | Histogramme | ax.hist |
| Relation entre deux variables | Nuage de points | ax.scatter |
Barres avec un repère d’objectif
order = reg.sort_values().index
ax.barh(order, reg[order] / 1e6, color='#10263A')
ax.scatter(tgt[order] / 1e6, order, color='#C89D62', marker='|', s=400, linewidths=3, label='Objectif')
Trier les barres facilite la comparaison ; le trait doré place l’objectif annuel de chaque région sur la même échelle. On voit immédiatement les régions qui dépassent leur objectif et celles qui restent en deçà.
Planches et enregistrement
plt.subplots(2, 2, figsize=(10, 7)) crée quatre axes dans une grille ; fig.tight_layout() évite les chevauchements. Enregistrez en PNG à 150 points par pouce pour un rapport, en SVG pour un document imprimé. Dans un script, les figures sont seulement enregistrées ; dans un carnet, elles s’affichent aussi sous la cellule.
Règles de lisibilité
- Un titre qui dit ce que montre le graphique, unités comprises.
- Une couleur d’accent pour ce qui compte, du gris pour le reste.
- Pas d’effet 3D ni de camembert à plus de cinq parts.
- Des axes qui commencent à zéro pour les barres.
Niveau 3 · Avancé — Chapitre 11
Introduction au machine learning avec scikit-learn
Le machine learning apprend une relation à partir d’exemples pour estimer une valeur inconnue. Bien utilisé, il complète l’analyse ; mal validé, il produit des chiffres trompeurs. Ce chapitre construit un premier modèle et, surtout, apprend à mesurer honnêtement sa qualité.
La question
Peut-on estimer les achats 2025 d’un client à partir de son comportement 2024 ? On construit une table d’une ligne par client (120 clients) avec des variables explicatives 2024 (achats, nombre de commandes, remise moyenne, part des commandes en ligne, segment, région) et la cible : les achats livrés 2025. La corrélation simple entre achats 2024 et 2025 vaut 0,34.
Un pipeline
X = data[['net24', 'orders24', 'disc24', 'web24', 'segment_code', 'region_code']]
y = data['net25']
prep = ColumnTransformer([('cat', OneHotEncoder(handle_unknown='ignore'),
['segment_code', 'region_code'])], remainder='passthrough')
model = Pipeline([('prep', prep), ('reg', LinearRegression())])
Un modèle ne lit que des nombres : OneHotEncoder transforme chaque segment et chaque région en colonnes 0/1. Le pipeline enchaîne préparation et modèle ; il garantit que la préparation est apprise sur les seules données d’entraînement, sans fuite d’information du jeu de test.
Valider honnêtement
cv = KFold(n_splits=5, shuffle=True, random_state=2026)
scores = cross_validate(model, X, y, cv=cv, scoring=('neg_mean_absolute_error', 'r2'))
La validation croisée découpe les clients en cinq groupes ; chaque groupe sert une fois de test pendant que le modèle apprend sur les quatre autres. On obtient une mesure moins dépendante du hasard d’un seul découpage. Deux métriques : l’erreur absolue moyenne (MAE), en dirhams, et le R², part de la variance expliquée (1 = parfait, 0 = pas mieux que la moyenne, négatif = pire que la moyenne).
Toujours comparer à une référence
La référence naïve estime les achats 2025 comme achats 2024 × croissance moyenne, croissance calculée sur les seuls plis d’entraînement. Résultats en validation croisée :
| Approche | MAE | R² |
|---|---|---|
| Référence naïve | 68 553 MAD | -1,07 |
| Régression linéaire | 47 006 MAD | 0,04 |
Le modèle réduit l’erreur moyenne de 31,4 % par rapport à la référence, mais son R² reste proche de zéro : il fait à peine mieux qu’une estimation par la moyenne. Conclusion honnête : avec ces variables et deux années de données, les achats 2025 d’un client sont mal prévisibles ; le modèle est utile pour éviter les grosses erreurs de la référence naïve, pas pour une prévision fine. Annoncer un modèle « performant » serait trompeur.
Niveau 3 · Avancé — Chapitre 12
Projet final : analyse commerciale de bout en bout
Le projet final réunit toute la chaîne : importer, contrôler, préparer, calculer les indicateurs, visualiser, analyser, modéliser et rendre compte. Il produit un rapport dont chaque chiffre est calculé par le code, ce qu’on attend d’un analyste de données en entreprise.
Le commanditaire et la question
Projet ISHRAQA7 Académie : analyse commerciale de bout en bout. La direction commerciale d’un distributeur d’équipements de bureau (étude de cas, données d’exercice) veut un bilan 2025 : où en sont les ventes par rapport à 2024 et à l’objectif, quelles régions et catégories expliquent les écarts, comment se répartissent les commandes, et peut-on estimer les achats futurs des clients ?
Les huit étapes
| Étape | Contenu | Sortie |
|---|---|---|
| 1. Import | Dix tables, types explicites | Dictionnaire de DataFrame |
| 2. Qualité | Clés uniques, clés étrangères, valeurs manquantes | Contrôles bloquants |
| 3. Préparation | Table de ventes : montant net, coût, délai | Une ligne par ligne de commande |
| 4. Indicateurs | Ventes, croissance, marge, panier, objectif, annulations, délai | kpi.csv |
| 5. Graphiques | Tendance, régions, catégories | Trois PNG |
| 6. Statistiques | Médiane, moyenne, IQR, atypiques | Résumé |
| 7. Modèle | Régression validée par validation croisée | MAE, R², référence |
| 8. Rapport | Synthèse Markdown générée | rapport.md |
Des contrôles qui arrêtent le traitement
q = {
'dup_order_id': int(T['orders']['order_id'].duplicated().sum()),
'orphan_lines': int((~T['order_lines']['order_id'].isin(T['orders']['order_id'])).sum()),
'missing_ship_not_cancelled': int((T['orders']['ship_date'].isna() & (T['orders']['status'] != 'cancelled')).sum()),
}
assert all(v == 0 for v in q.values()), q
Si une clé est dupliquée ou orpheline, le script s’arrête et affiche le contrôle en cause : mieux vaut aucun rapport qu’un rapport faux. Tous les contrôles du projet valent 0 sur les données de la formation.
Un rapport généré, pas recopié
report = f"""| Ventes nettes (MAD) | {fmt(k4['net'], ',.0f')} | {fmt(k5['net'], ',.0f')} |
| Taux de marge | {fmt(k4['margin_rate'], '.1%')} | {fmt(k5['margin_rate'], '.1%')} |"""
(P / 'rapport.md').write_text(report, encoding='utf-8')
La fonction fmt du script adapte les séparateurs à la langue du rapport : espace fine pour les milliers et virgule décimale en français.
Chaque valeur du rapport est insérée par le code à partir des calculs : si les données changent, il suffit de relancer le script. Le format Markdown se lit tel quel et se convertit facilement en HTML ou en PDF.
Résultats obtenus sur les données de la formation
| Indicateur 2025 | Valeur |
|---|---|
| Ventes nettes (2024) | 15 097 590 MAD (13 556 439 MAD) |
| Croissance | 11,4 % |
| Taux de marge (2024) | 38,3 % (36,3 %) |
| Atteinte de l’objectif | 99,4 % |
| Commandes livrées / panier moyen | 1 628 / 9 274 MAD |
| Taux d’annulation / délai moyen | 3,6 % / 2,4 jours |
Grille d’évaluation
| Critère | Points |
|---|---|
| Organisation du code : fonctions, noms, commentaires, chemins relatifs | 20 |
| Qualité des données : contrôles bloquants et documentés | 20 |
| Exactitude des indicateurs (valeurs de référence) | 20 |
| Graphiques lisibles et pertinents | 15 |
| Statistiques et modèle validés, limites expliquées | 15 |
| Rapport généré, conclusions argumentées | 10 |
Cahier des charges du projet final
- Importer les dix tables avec des types explicites.
- Écrire des contrôles de qualité bloquants (clés, valeurs manquantes).
- Construire la table de ventes avec montant net, coût et délai.
- Calculer les indicateurs 2024 et 2025 et les enregistrer dans kpi.csv.
- Produire trois graphiques et une analyse statistique des commandes.
- Estimer les achats des clients avec validation croisée et référence naïve.
- Générer un rapport Markdown et rédiger trois recommandations.
