Data & Big Data

Python Matplotlib Seaborn expliqué simplement (avec schémas et vrai code)

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

REHOUMA Haythem

• 15 min read
Python Matplotlib Seaborn expliqué simplement (avec schémas et vrai code)

Un guide qui va droit au but : Python Matplotlib Seaborn décortiqué avec des schémas, des exemples concrets et des commandes testées. Tout vient d'un cours structuré de 11 chapitres — en voici le meilleur.

tl;dr
  • Introduction et Installation
  • Bases de Matplotlib
  • Graphiques essentiels Matplotlib
  • Personnalisation et styles
  • Subplots et figures complexes
~$ cat ./parcours.md # Python Matplotlib Seaborn — 10 chapitres
01
Introduction et Installation
→ Présentation du cours→ Installer Python, Anaconda, Jupyter et les bibliothèques+ 1 autres leçons
02
Bases de Matplotlib
→ Anatomie d’une figure Matplotlib→ Pyplot vs API objet-orientée+ 1 autres leçons
03
Graphiques essentiels Matplotlib
→ Graphiques en lignes (line charts)→ Diagrammes en barres (bar charts)+ 2 autres leçons
04
Personnalisation et styles
→ Couleurs, marqueurs et styles de lignes→ Titres, légendes, annotations et texte+ 1 autres leçons
05
Subplots et figures complexes
→ Subplots avec plt.subplots()→ GridSpec pour layouts asymétriques+ 1 autres leçons
06
Introduction à Seaborn
→ C’est quoi Seaborn et en quoi diffère-t-il de Matplotlib ?→ Installer Seaborn et charger les datasets intégrés+ 1 autres leçons
07
Visualisations statistiques Seaborn
→ Distributions avec histplot, kdeplot et displot→ Boxplot, violinplot et stripplot+ 2 autres leçons
08
Visualisations multivariées Seaborn
→ pairplot et matrices de corrélation→ heatmap — cartes de chaleur+ 1 autres leçons
🏁
Projet final (+ 2 chapitres en chemin)
→ Tu repars avec un projet concret et démontrable

Exploration et visualisations initiales (EDA)

NOTEObjectif — Réaliser l’exploration des données (EDA) du dataset ventes pour identifier les insights clés à mettre en avant dans le dashboard final.

Pourquoi une EDA avant le dashboard ?

TIPRègle d’or — On ne conçoit jamais un dashboard sans avoir d’abord compris les données. L’EDA révèle les patterns, les outliers, et les insights qui devront être mis en avant.

Dans cette leçon, nous allons créer 5 graphiques exploratoires pour comprendre :

Setup commun

output
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme(
    style="whitegrid",
    context="notebook",
    palette="viridis",
    font_scale=1.05,
)

df = pd.read_csv("ventes_2024.csv", parse_dates=["date"])
print(df.info())
print(df.describe())

Graphique 1 : Distribution du panier moyen

output
fig, ax = plt.subplots(figsize=(10, 5))
sns.histplot(data=df, x="vente_eur", kde=True, bins=40, color="#7c3aed", ax=ax)

mean_vente = df["vente_eur"].mean()
median_vente = df["vente_eur"].median()
ax.axvline(mean_vente, color="red", linestyle="--", linewidth=2, label=f"Moyenne : {mean_vente:.0f} EUR")
ax.axvline(median_vente, color="orange", linestyle="--", linewidth=2, label=f"Mediane : {median_vente:.0f} EUR")

ax.set_title("Distribution du panier moyen", fontweight="bold")
ax.set_xlabel("Montant de la commande (EUR)")
ax.set_ylabel("Nombre de transactions")
ax.legend()
sns.despine()
plt.tight_layout()
plt.show()
TIPInsight EDA #1 — La distribution est asymétrique à droite (skewed right). La moyenne est tirée par quelques très grosses commandes, alors que la médiane reflète mieux le comportement « typique ».

Graphique 2 : Évolution mensuelle du CA

output
monthly = df.groupby("mois").agg(
    ca=("vente_eur", "sum"),
    nb_cmd=("vente_eur", "count"),
).reset_index()

fig, ax = plt.subplots(figsize=(11, 5))
sns.lineplot(data=monthly, x="mois", y="ca", marker="o", linewidth=2.5, color="#7c3aed", ax=ax)
ax.fill_between(monthly["mois"], monthly["ca"], alpha=0.15, color="#7c3aed")

best_month = monthly.loc[monthly["ca"].idxmax()]
ax.annotate(
    f"Pic : {best_month['ca']:,.0f} EUR",
    xy=(best_month["mois"], best_month["ca"]),
    xytext=(best_month["mois"], best_month["ca"] + 1500),
    ha="center", fontsize=11, fontweight="bold", color="red",
    arrowprops=dict(arrowstyle="->", color="red")
)

ax.set_title("Evolution mensuelle du chiffre d'affaires 2024", fontweight="bold")
ax.set_xlabel("Mois"); ax.set_ylabel("CA (EUR)")
ax.set_xticks(range(1, 13))
sns.despine()
plt.tight_layout()
plt.show()
TIPInsight EDA #2 — Pic d’activité en période festive (novembre / décembre) ; creux relatifs en février-mars.

Graphique 3 : Performance par catégorie

output
cat_perf = df.groupby("categorie").agg(
    ca=("vente_eur", "sum"),
    marge=("marge_eur", "sum"),
).reset_index().sort_values("ca", ascending=True)

fig, ax = plt.subplots(figsize=(10, 5))
y_pos = range(len(cat_perf))
ax.barh(y_pos, cat_perf["ca"], color="#a78bfa", label="CA", alpha=0.8)
ax.barh(y_pos, cat_perf["marge"], color="#7c3aed", label="Marge", alpha=0.9)

for i, (ca, marge) in enumerate(zip(cat_perf["ca"], cat_perf["marge"])):
    ax.text(ca + 2000, i, f"{ca:,.0f} EUR", va="center", fontsize=10, fontweight="bold")

ax.set_yticks(y_pos)
ax.set_yticklabels(cat_perf["categorie"])
ax.set_title("CA et marges par categorie produit", fontweight="bold")
ax.set_xlabel("Montant (EUR)")
ax.legend(loc="lower right")
sns.despine()
plt.tight_layout()
plt.show()
TIPInsight EDA #3 — L’électronique et les vêtements génèrent le plus de CA, mais leur ratio marge / CA varie. Le sport, même s’il fait moins de CA, peut avoir une meilleure marge relative.

Graphique 4 : Performance par magasin (boxplot)

output
fig, ax = plt.subplots(figsize=(11, 5))
order = df.groupby("magasin")["vente_eur"].median().sort_values(ascending=False).index

sns.boxplot(data=df, x="magasin", y="vente_eur", order=order,
            palette="viridis", hue="magasin", legend=False, ax=ax)
sns.stripplot(data=df, x="magasin", y="vente_eur", order=order,
              color="black", alpha=0.15, size=2, ax=ax)

ax.set_title("Distribution des paniers par magasin (trie par mediane)", fontweight="bold")
ax.set_xlabel("Magasin"); ax.set_ylabel("Panier (EUR)")
sns.despine()
plt.tight_layout()
plt.show()
TIPInsight EDA #4 — Les magasins de Paris et Lyon ont des paniers médians plus élevés. Bordeaux affiche plus d’outliers vers le haut (grosses commandes ponctuelles).

Graphique 5 : Corrélations numériques (heatmap)

output
numeric_cols = ["vente_eur", "marge_eur", "nb_articles", "mois", "trimestre"]
corr = df[numeric_cols].corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(corr, annot=True, fmt=".2f", cmap="vlag", center=0,
            square=True, linewidths=0.5, cbar_kws={"shrink": 0.7}, ax=ax)
ax.set_title("Matrice de correlation des variables numeriques", fontweight="bold")
plt.tight_layout()
plt.show()

Premier script de visualisation

NOTEObjectif — Créer votre tout premier graphique Matplotlib : tracer la fonction y = sin(x) entre 0 et 2π. Cet exercice valide votre installation et vous donne une base concrète pour la suite du cours.

Objectifs pédagogiques

TIPÀ l’issue de ce module — Vous saurez écrire un script Python complet qui génère des données avec NumPy, les visualise avec Matplotlib et sauvegarde le résultat en image. Vous comprendrez aussi pourquoi on commence toujours par import numpy as np et import matplotlib.pyplot as plt.

Le script complet : 8 lignes pour un premier graphique

Voici le script que nous allons décortiquer ensemble. Copiez-le dans un nouveau notebook Jupyter :

output
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title("Ma premiere fonction sinus")
plt.xlabel("x (radians)")
plt.ylabel("sin(x)")
plt.grid(True)
plt.show()

Exécutez la cellule (touche Shift + Enter). Vous devez voir apparaître une belle courbe sinusoïdale qui ondule entre −1 et +1.

TIPBravo ! Vous venez de créer votre premier graphique Python. Maintenant, comprenons ligne par ligne ce qui se passe.

Décortication ligne par ligne

Lignes 1-2 : les imports

output
import numpy as np
import matplotlib.pyplot as plt

Deux conventions universelles :

WARNINGRègle d’or — Toujours écrire import matplotlib.pyplot as plt et jamais import matplotlib as plt. Le module pyplot contient toutes les fonctions plot(), title(), etc.

Ligne 3 : générer l’axe x

output
x = np.linspace(0, 2 * np.pi, 100)

np.linspace(début, fin, n) retourne un tableau de n valeurs régulièrement espacées entre début et fin. Ici : 100 points entre 0 et 2π (soit environ 6,28).

Résultat : x = [0.0, 0.063, 0.127, 0.190, ..., 6.283]

Ligne 4 : calculer y = sin(x)

output
y = np.sin(x)

NumPy applique sin() à chaque élément du tableau x en une seule opération. C’est la magie vectorielle de NumPy : pas de boucle, super rapide.

Résultat : y = [0.0, 0.063, 0.127, ..., -0.0]

Ligne 5 : tracer la courbe

output
plt.plot(x, y)

plt.plot(x, y) dessine une ligne reliant chaque point (x[i], y[i]). C’est la fonction la plus utilisée de tout Matplotlib.

Lignes 6-8 : titre, labels et grille

output
plt.title("Ma premiere fonction sinus")
plt.xlabel("x (radians)")
plt.ylabel("sin(x)")
plt.grid(True)

Premier graphique en ligne avec des données réelles

NOTEObjectif — Passer des données synthétiques (sinus, cosinus) à des données réelles. Charger un fichier CSV avec Pandas, comprendre la structure, et tracer un graphique en ligne professionnel.

Objectifs pédagogiques

TIPÀ l’issue de ce module — Vous saurez charger un CSV, le manipuler avec Pandas, tracer une ou plusieurs séries temporelles, et exporter le tout proprement.

Notre dataset : ventes mensuelles fictives

Pour cet exercice, on crée un petit DataFrame avec 12 mois de ventes pour 3 produits différents :

output
import pandas as pd
import matplotlib.pyplot as plt

data = {
    "Mois": ["Jan", "Fev", "Mar", "Avr", "Mai", "Juin",
             "Juil", "Aout", "Sep", "Oct", "Nov", "Dec"],
    "Produit A": [120, 135, 148, 160, 175, 210,
                   250, 245, 200, 170, 140, 290],
    "Produit B": [80, 85, 90, 95, 100, 110,
                   130, 135, 120, 100, 90, 180],
    "Produit C": [50, 55, 60, 70, 85, 100,
                   120, 115, 95, 75, 60, 150],
}
df = pd.DataFrame(data)
print(df.head())

Résultat affiché :

output
Mois  Produit A  Produit B  Produit C
0  Jan        120         80         50
1  Fev        135         85         55
2  Mar        148         90         60
3  Avr        160         95         70
4  Mai        175        100         85
TIPPourquoi un DataFrame ? — Un DataFrame Pandas est un tableau structuré (colonnes nommées, lignes indexées). C’est le format standard pour passer des données à Matplotlib ou Seaborn.

Tracer une seule colonne

output
fig, ax = plt.subplots(figsize=(10, 5))

ax.plot(df["Mois"], df["Produit A"], color="purple", linewidth=2)
ax.set_title("Ventes mensuelles du Produit A", fontsize=14)
ax.set_xlabel("Mois")
ax.set_ylabel("Unites vendues")
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Vous obtenez un graphique propre montrant la saisonnalité des ventes (pic en juillet, explosion en décembre).

Tracer plusieurs séries sur le même graphique

output
fig, ax = plt.subplots(figsize=(12, 6))

ax.plot(df["Mois"], df["Produit A"], label="Produit A", linewidth=2, marker="o")
ax.plot(df["Mois"], df["Produit B"], label="Produit B", linewidth=2, marker="s")
ax.plot(df["Mois"], df["Produit C"], label="Produit C", linewidth=2, marker="^")

ax.set_title("Ventes mensuelles par produit", fontsize=14, pad=15)
ax.set_xlabel("Mois", fontsize=12)
ax.set_ylabel("Unites vendues", fontsize=12)
ax.legend(loc="upper left", fontsize=11)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Trois nouvelles techniques appliquées :

Marqueurs disponibles

CodeMarqueurCodeMarqueur
"o"Cercle"s"Carré
"^"Triangle haut"v"Triangle bas
"<"Triangle gauche">"Triangle droite
"D"Diamant"d"Diamant fin
"*"Étoile"+"Plus
"x"Croix"."Point
"P"Plus rempli"X"Croix remplie

Charger un vrai fichier CSV

Dans la vraie vie, vos données sont dans un fichier .csv. Voici comment le charger :

output
# Si le fichier est dans le meme dossier
df = pd.read_csv("ventes.csv")

# Si le fichier est sur le web
url = "https://raw.githubusercontent.com/exemple/data/main/ventes.csv"
df = pd.read_csv(url)

# Avec un autre separateur (point-virgule)
df = pd.read_csv("ventes.csv", sep=";")

# Avec parsing automatique des dates
df = pd.read_csv("ventes.csv", parse_dates=["date"])

print(df.head())
print(df.dtypes)
NOTEAstuce débug — Toujours vérifier df.dtypes après un chargement. Si une colonne attendue en nombre est en object, c’est qu’il y a des virgules décimales françaises ou des cellules vides à nettoyer.

Astuce Pandas + Matplotlib : raccourci intégré

Pandas a son propre wrapper Matplotlib. Vous pouvez tracer directement depuis un DataFrame :

output
df.set_index("Mois").plot(figsize=(10, 5), marker="o")
plt.title("Ventes par produit (style Pandas)")
plt.ylabel("Unites")
plt.grid(True, alpha=0.3)
plt.show()
va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet Python Matplotlib Seaborn (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 Matplotlib Seaborn ?
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 Matplotlib Seaborn : il enchaîne les 37 leçons dans l'ordre, avec exercices et projet final.
./a-lire-aussi
→ AWS Data Engineering Bootcamp expliqué simplement (avec schémas et vrai code)→ Lance-toi en AWS Données Temps Réel : ton premier pas concret aujourd'hui→ Python Data Science : les 9 étapes clés pour passer de zéro à opérationnel

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

Stay up to date

Enter your email
Subscribe