MAGAZINE IA & COMPÉTENCES NUMÉRIQUES Apprendre, du débutant à l’expert
Contact ÉDITION 2026
ISHRAQA7 — Magazine des savoir-faire numériques
ISHRAQA 7 ACADEMY · Excel & Data

Python & Data Science : de la première ligne de code au projet d’analyse

Douze chapitres progressifs : bases de Python, fichiers et environnements, NumPy, pandas, nettoyage, analyse exploratoire, statistiques, Matplotlib et premier modèle scikit-learn validé, avec scripts et carnets Jupyter réellement exécutés.

  • NiveauDébutant → Avancé
  • Programme de la formation12 modules
  • Fichiers de la formationPDF · TXT · PY · IPYNB · CSV · ZIP

Aussi disponible en العربية English

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

  1. 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.
  2. Décompressez l’archive de la formation dans un dossier court, par exemple C:\ISHRAQA7\python\. Elle contient data/, scripts/, notebooks/ et requirements.txt.
  3. 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.
  4. Lancez jupyter lab depuis 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

  1. Formuler une question précise (« quel canal annule le plus ? »).
  2. Choisir le grain et la mesure adaptés (commande, taux d’annulation).
  3. Calculer, puis vérifier l’ordre de grandeur.
  4. 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.

Vérifiez vos acquis

1. Python pour l’analyse de données : premiers pas
1. Quelle bibliothèque de la formation sert à manipuler des tables de données ?
2. Que renvoie csv.DictReader pour chaque ligne du fichier ?
3. Quel est l’intérêt principal d’un carnet Jupyter ?
2. Variables, types et structures de données
1. Quelle structure choisir pour retrouver rapidement le prix d’un produit à partir de son code ?
2. Que produit l’expression int('4 pcs') ?
3. Que contient l’ensemble {p['cat'] for p in products} ?
3. Conditions, boucles, fonctions et modules
1. Que se passe-t-il si l’on appelle net_amount(4, 2450.0) sans remise ?
2. Dans une suite if / elif, quelle branche s’exécute ?
3. Pourquoi éviter un except: sans type d’erreur ?
4. Fichiers, dépendances et environnements
1. Pourquoi calculer ROOT à partir de __file__ ?
2. À quoi sert un environnement virtuel ?
3. Que garantit un requirements.txt avec des versions figées ?
5. Calcul numérique avec NumPy
1. Que fait l’expression qty * price lorsque qty et price sont deux tableaux NumPy de même longueur ?
2. Que renvoie (net > 10_000).sum() ?
3. Pourquoi fixer la graine d’un générateur aléatoire ?
6. Manipuler des tables avec pandas
1. Pourquoi déclarer dtype={'order_id': str} à la lecture ?
2. Que vérifie validate='many_to_one' dans un merge ?
3. Quelle méthode compte les commandes distinctes d’une table au grain ligne ?
7. Nettoyage et préparation des données
1. Pourquoi lire l’extrait brut avec dtype=str ?
2. Que fait errors='coerce' dans pd.to_datetime ?
3. Quel est le meilleur contrôle final d’un nettoyage ?
8. Analyse exploratoire des données (EDA)
1. Pourquoi construire une table au grain commande pour étudier le panier ?
2. Que fait normalize='index' dans pd.crosstab ?
3. Dans une activité saisonnière, à quoi comparer les ventes d’un trimestre ?
9. Statistiques descriptives
1. Pour décrire une commande « typique » dans une distribution très asymétrique, quel indicateur privilégier ?
2. Que signifie une valeur au-dessus de Q3 + 1,5 × IQR ?
3. Une corrélation de 0,8 entre deux variables prouve-t-elle que l’une cause l’autre ?
10. Visualiser avec Matplotlib
1. Quel graphique choisir pour comparer les ventes de quatre régions ?
2. Pourquoi travailler avec l’objet ax plutôt qu’avec les fonctions globales plt ?
3. Que fait fig.tight_layout() ?
11. Introduction au machine learning avec scikit-learn
1. Pourquoi utiliser un pipeline qui inclut la préparation des données ?
2. Que signifie un R² proche de 0 en validation croisée ?
3. Pourquoi comparer le modèle à une référence naïve ?
12. Projet final : analyse commerciale de bout en bout
1. Pourquoi un contrôle de qualité doit-il arrêter le script en cas d’échec ?
2. Quel est l’intérêt d’un rapport généré par le code ?
3. Comment présenter un modèle dont le R² est proche de 0 ?

Lexique de la page

Les notions essentielles de ce contenu, chacune avec une définition courte.

Python
Langage de programmation lisible, très utilisé en analyse de données, en automatisation et en intelligence artificielle.
CSV
Fichier texte simple où les valeurs sont séparées par un délimiteur ; le format le plus courant pour échanger des données entre logiciels.
tableau croisé dynamique
Outil d’Excel qui résume des milliers de lignes en quelques secondes : totaux, moyennes et comptages selon les catégories choisies.
indicateur clé de performance
Chiffre suivi régulièrement pour mesurer l’avancement vers un objectif précis, par exemple une marge ou un taux de retard.

Fichiers de la formation

Choisissez la langue, puis le format qui vous convient.

العربية

FichierFormatTailleTélécharger
الدليل الكامل للدورة PDF 1,8 Mo Télécharger — الدليل الكامل للدورة (PDF)
دفتر التمارين PDF 618 Ko Télécharger — دفتر التمارين (PDF)
الحلول المشروحة PDF 690 Ko Télécharger — الحلول المشروحة (PDF)
دليل التثبيت PDF 145 Ko Télécharger — دليل التثبيت (PDF)
المشروع النهائي: التقرير والمنهجية PDF 262 Ko Télécharger — المشروع النهائي: التقرير والمنهجية (PDF)
سكربت المشروع النهائي ⁦(Python)⁩ Python 12 Ko Télécharger — سكربت المشروع النهائي ⁦(Python)⁩ (Python)
دفتر المشروع النهائي، منفَّذ Notebook 220 Ko Télécharger — دفتر المشروع النهائي، منفَّذ (Notebook)
بيانات ⁦CSV⁩ للحالة الدراسية (11 ملفًا) ZIP 83 Ko Télécharger — بيانات ⁦CSV⁩ للحالة الدراسية (11 ملفًا) (ZIP)
سكربتات ⁦Python⁩ للفصول الاثني عشر ZIP 23 Ko Télécharger — سكربتات ⁦Python⁩ للفصول الاثني عشر (ZIP)
دفاتر ⁦Jupyter⁩: حلول منفَّذة وتمارين ZIP 450 Ko Télécharger — دفاتر ⁦Jupyter⁩: حلول منفَّذة وتمارين (ZIP)
الحزمة التطبيقية الكاملة ZIP 557 Ko Télécharger — الحزمة التطبيقية الكاملة (ZIP)
Dépendances (requirements.txt) Commun TXT 1 Ko Télécharger — Dépendances (requirements.txt) (TXT)
Extrait brut à nettoyer (chapitre 7) Commun CSV 57 Ko Télécharger — Extrait brut à nettoyer (chapitre 7) (CSV)

Français

FichierFormatTailleTélécharger
Manuel complet de la formation PDF 1,6 Mo Télécharger — Manuel complet de la formation (PDF)
Cahier d’exercices PDF 575 Ko Télécharger — Cahier d’exercices (PDF)
Corrigés commentés PDF 625 Ko Télécharger — Corrigés commentés (PDF)
Guide d’installation PDF 117 Ko Télécharger — Guide d’installation (PDF)
Projet final : rapport et méthode PDF 244 Ko Télécharger — Projet final : rapport et méthode (PDF)
Script du projet final (Python) Python 11 Ko Télécharger — Script du projet final (Python) (Python)
Carnet du projet final, exécuté Notebook 232 Ko Télécharger — Carnet du projet final, exécuté (Notebook)
Données CSV du cas pratique (11 fichiers) ZIP 83 Ko Télécharger — Données CSV du cas pratique (11 fichiers) (ZIP)
Les 12 scripts Python des chapitres ZIP 22 Ko Télécharger — Les 12 scripts Python des chapitres (ZIP)
Carnets Jupyter : corrigés exécutés et exercices ZIP 466 Ko Télécharger — Carnets Jupyter : corrigés exécutés et exercices (ZIP)
Kit pratique complet ZIP 572 Ko Télécharger — Kit pratique complet (ZIP)
Dépendances (requirements.txt) Commun TXT 1 Ko Télécharger — Dépendances (requirements.txt) (TXT)
Extrait brut à nettoyer (chapitre 7) Commun CSV 57 Ko Télécharger — Extrait brut à nettoyer (chapitre 7) (CSV)

English

FichierFormatTailleTélécharger
Complete course manual PDF 1,6 Mo Télécharger — Complete course manual (PDF)
Exercise workbook PDF 556 Ko Télécharger — Exercise workbook (PDF)
Worked answers PDF 609 Ko Télécharger — Worked answers (PDF)
Installation guide PDF 116 Ko Télécharger — Installation guide (PDF)
Final project: report and method PDF 237 Ko Télécharger — Final project: report and method (PDF)
Final project script (Python) Python 10 Ko Télécharger — Final project script (Python) (Python)
Final project notebook, executed Notebook 226 Ko Télécharger — Final project notebook, executed (Notebook)
Case-study CSV data (11 files) ZIP 83 Ko Télécharger — Case-study CSV data (11 files) (ZIP)
The 12 chapter Python scripts ZIP 20 Ko Télécharger — The 12 chapter Python scripts (ZIP)
Jupyter notebooks: executed solutions and exercises ZIP 453 Ko Télécharger — Jupyter notebooks: executed solutions and exercises (ZIP)
Complete practice kit ZIP 557 Ko Télécharger — Complete practice kit (ZIP)
Dépendances (requirements.txt) Commun TXT 1 Ko Télécharger — Dépendances (requirements.txt) (TXT)
Extrait brut à nettoyer (chapitre 7) Commun CSV 57 Ko Télécharger — Extrait brut à nettoyer (chapitre 7) (CSV)