Visualisation Python : Guide 2026

Introduction : Pourquoi la Visualisation de Données est Incontournable en 2026

Soyons honnêtes : en data science, les chiffres seuls ne suffisent jamais. Vous pouvez avoir le modèle de machine learning le plus performant du monde, le pipeline de données le plus optimisé — si vous ne savez pas communiquer vos résultats visuellement, leur impact reste franchement limité. La visualisation de données, c'est l'art de transformer des tableaux de nombres en histoires compréhensibles. Et en 2026, les outils Python pour y parvenir n'ont jamais été aussi puissants.

L'écosystème Python de visualisation s'est considérablement enrichi ces dernières années. Matplotlib reste la fondation incontournable, Seaborn simplifie la création de graphiques statistiques élégants, et Plotly offre une interactivité native qui séduit de plus en plus de professionnels. Chacune a ses forces et ses cas d'usage privilégiés.

Alors, dans ce guide, on va explorer ces trois piliers en profondeur. On passera des fondamentaux aux techniques avancées, avec des exemples de code concrets que vous pouvez copier-coller directement. Que vous soyez data analyst, data scientist ou ingénieur ML, il y a forcément quelque chose ici pour vous.

Matplotlib 3.10 : La Fondation Modernisée

Matplotlib, c'est un peu le grand-père de la visualisation en Python. Créé en 2003, il a posé les bases sur lesquelles presque toutes les autres bibliothèques se sont construites. Mais attention — grand-père ne veut absolument pas dire dépassé. La version 3.10, sortie en décembre 2024, apporte des nouveautés qui le maintiennent parfaitement pertinent.

Installation et Configuration

L'installation est classique via pip. Pour un environnement complet, installez aussi NumPy et Pandas (vous les utiliserez de toute façon) :

# Installation de Matplotlib et dépendances
pip install matplotlib numpy pandas

# Vérification de la version
python -c "import matplotlib; print(matplotlib.__version__)"

Les Bases : Créer Votre Premier Graphique

Commençons par les fondamentaux. L'interface pyplot de Matplotlib offre une API simple et intuitive pour créer des graphiques rapidement :

import matplotlib.pyplot as plt
import numpy as np

# Générer des données
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Créer un graphique avec deux courbes
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, y1, label="Sinus", color="#2196F3", linewidth=2)
ax.plot(x, y2, label="Cosinus", color="#FF5722", linewidth=2, linestyle="--")

# Personnaliser le graphique
ax.set_title("Fonctions Trigonométriques", fontsize=16, fontweight="bold")
ax.set_xlabel("x", fontsize=12)
ax.set_ylabel("y", fontsize=12)
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig("trigonometrie.png", dpi=150)
plt.show()

Notez qu'on utilise l'interface orientée objet (fig, ax) plutôt que l'interface fonctionnelle (plt.plot()). C'est la pratique recommandée en 2026 — et honnêtement, ça vous évitera pas mal de frustrations quand vos graphiques deviendront plus complexes.

Nouveauté 3.10 : Le Cycle de Couleurs petroff10

La version 3.10 introduit petroff10, un nouveau cycle de couleurs conçu algorithmiquement pour être esthétique et accessible aux personnes daltoniennes. Ça peut sembler mineur, mais l'accessibilité des visualisations devient un sujet sérieux dans le monde professionnel.

import matplotlib.pyplot as plt
import numpy as np

# Activer le style petroff10
plt.style.use("petroff10")

# Créer un graphique avec plusieurs séries
fig, ax = plt.subplots(figsize=(10, 6))

categories = ["T1", "T2", "T3", "T4"]
for i in range(5):
    valeurs = np.random.randint(20, 100, size=4)
    ax.plot(categories, valeurs, marker="o", linewidth=2,
            label=f"Produit {i+1}")

ax.set_title("Ventes Trimestrielles par Produit", fontsize=14)
ax.set_ylabel("Ventes (k€)")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Les couleurs sont automatiquement choisies pour maximiser le contraste visuel, même pour les personnes avec une vision altérée. Un vrai progrès par rapport aux palettes par défaut précédentes.

Nouveaux Colormaps : berlin, managua et vanimo

Trois nouveaux colormaps divergents ont été ajoutés : berlin, managua et vanimo. Ils sont particulièrement utiles pour représenter des données qui divergent autour d'une valeur centrale — comme des écarts par rapport à une moyenne ou des variations de température.

import matplotlib.pyplot as plt
import numpy as np

# Données fictives : écarts de température
np.random.seed(42)
data = np.random.randn(20, 20)

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

for ax, cmap_name in zip(axes, ["berlin", "managua", "vanimo"]):
    im = ax.imshow(data, cmap=cmap_name, aspect="auto")
    ax.set_title(f"Colormap : {cmap_name}", fontsize=13)
    plt.colorbar(im, ax=ax, shrink=0.8)

plt.suptitle("Nouveaux Colormaps Divergents de Matplotlib 3.10",
             fontsize=15, fontweight="bold", y=1.02)
plt.tight_layout()
plt.show()

Graphiques Multi-Panneaux pour l'Analyse Exploratoire

En 2026, la tendance est clairement au storytelling visuel. Les data scientists construisent des tableaux de bord analytiques en combinant plusieurs graphiques dans une même figure. Et c'est là que Matplotlib brille vraiment, grâce à son système de sous-graphiques flexible :

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# Simuler des données de ventes
np.random.seed(42)
mois = pd.date_range("2025-01", periods=12, freq="ME")
ventes = np.random.randint(50, 200, size=12)
benefices = ventes * np.random.uniform(0.1, 0.3, size=12)
categories = ["Électronique", "Vêtements", "Alimentation", "Maison"]
parts = [35, 25, 22, 18]

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Graphique 1 : Évolution des ventes
axes[0, 0].bar(mois, ventes, color="#2196F3", alpha=0.8)
axes[0, 0].set_title("Ventes Mensuelles (k€)")
axes[0, 0].tick_params(axis="x", rotation=45)

# Graphique 2 : Bénéfices
axes[0, 1].fill_between(mois, benefices, alpha=0.4, color="#4CAF50")
axes[0, 1].plot(mois, benefices, color="#4CAF50", linewidth=2)
axes[0, 1].set_title("Bénéfices Mensuels (k€)")
axes[0, 1].tick_params(axis="x", rotation=45)

# Graphique 3 : Répartition par catégorie
axes[1, 0].pie(parts, labels=categories, autopct="%1.1f%%",
               startangle=90)
axes[1, 0].set_title("Répartition par Catégorie")

# Graphique 4 : Corrélation ventes/bénéfices
axes[1, 1].scatter(ventes, benefices, c="#FF5722", s=80, alpha=0.7)
axes[1, 1].set_xlabel("Ventes (k€)")
axes[1, 1].set_ylabel("Bénéfices (k€)")
axes[1, 1].set_title("Corrélation Ventes / Bénéfices")

plt.suptitle("Tableau de Bord Commercial 2025",
             fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()

Ce type de figure multi-panneaux permet de raconter une histoire complète en un seul coup d'œil. C'est exactement le genre de rendu que les décideurs apprécient quand on leur présente des résultats d'analyse.

Support Préliminaire de Python Free-Threaded

Matplotlib 3.10 introduit aussi un support préliminaire pour le mode free-threaded de CPython 3.13 (PEP 703). Concrètement, vous pouvez utiliser une Figure dans un seul thread sans problème, mais modifier des données depuis un autre thread peut causer des incohérences. L'utilisation de l'état global pyplot dans un contexte multi-thread reste déconseillée pour l'instant. C'est un premier pas — pas une solution complète — vers un futur concurrent pour Matplotlib.

Seaborn : L'Élégance Statistique

Si Matplotlib est le moteur, Seaborn c'est la carrosserie. Construit au-dessus de Matplotlib, Seaborn offre une API de haut niveau spécialisée dans la visualisation statistique. Sa philosophie est simple : des graphiques beaux et informatifs, avec le moins de code possible.

Pourquoi Seaborn en 2026 ?

La version actuelle (0.13.2) a consolidé plusieurs avancées majeures. L'interface objects, introduite dans la version 0.12, propose une approche déclarative et composable inspirée de la grammaire des graphiques. Les fonctions catégorielles ont été profondément remaniées dans la 0.13, et la bibliothèque supporte désormais des alternatives à Pandas comme Polars.

Personnellement, c'est la lib que j'utilise le plus pour l'exploration rapide de données. Quelques lignes et vous avez un graphique qui en dit long.

Distributions et Graphiques Statistiques

Seaborn excelle dans l'affichage de distributions. Là où Matplotlib demande plusieurs lignes de configuration, Seaborn produit un résultat élégant en une seule instruction :

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# Créer un jeu de données simulé
np.random.seed(42)
n = 500
df = pd.DataFrame({
    "age": np.random.normal(35, 10, n).astype(int),
    "salaire": np.random.normal(45000, 15000, n),
    "departement": np.random.choice(
        ["Ingénierie", "Marketing", "Finance", "RH"], n
    ),
    "experience": np.random.randint(0, 25, n)
})

# Distribution des salaires par département
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# Violin plot
sns.violinplot(data=df, x="departement", y="salaire",
               ax=axes[0], palette="muted")
axes[0].set_title("Distribution des Salaires par Département")
axes[0].set_ylabel("Salaire Annuel (€)")
axes[0].tick_params(axis="x", rotation=15)

# Box plot enrichi avec points individuels
sns.boxplot(data=df, x="departement", y="salaire",
            ax=axes[1], palette="pastel", width=0.5)
sns.stripplot(data=df, x="departement", y="salaire",
              ax=axes[1], color="0.3", size=2, alpha=0.3)
axes[1].set_title("Box Plot avec Points Individuels")
axes[1].set_ylabel("Salaire Annuel (€)")
axes[1].tick_params(axis="x", rotation=15)

plt.tight_layout()
plt.show()

Le violinplot montre la forme complète de la distribution, tandis que le boxplot combiné au stripplot révèle à la fois les statistiques résumées et la distribution réelle des points. C'est une technique redoutablement efficace pour l'analyse exploratoire — et visuellement, ça a quand même beaucoup plus de gueule qu'un simple histogramme.

Matrices de Corrélation avec Heatmap

La heatmap de Seaborn est probablement l'un des graphiques les plus utilisés en data science. Et pour cause : elle permet de visualiser instantanément les corrélations entre variables numériques.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Jeu de données avec corrélations
np.random.seed(42)
n = 200
heures_travail = np.random.normal(40, 8, n)
df = pd.DataFrame({
    "Heures de Travail": heures_travail,
    "Productivité": heures_travail * 0.7 + np.random.normal(0, 5, n),
    "Stress": heures_travail * 0.5 + np.random.normal(0, 8, n),
    "Satisfaction": 100 - heures_travail * 0.8 + np.random.normal(0, 10, n),
    "Salaire": heures_travail * 800 + np.random.normal(30000, 5000, n)
})

# Calcul de la matrice de corrélation
corr = df.corr()

# Visualisation
fig, ax = plt.subplots(figsize=(8, 7))
mask = np.triu(np.ones_like(corr, dtype=bool))
sns.heatmap(corr, mask=mask, annot=True, fmt=".2f",
            cmap="RdBu_r", center=0, square=True,
            linewidths=1, ax=ax,
            vmin=-1, vmax=1)
ax.set_title("Matrice de Corrélation — Bien-être au Travail",
             fontsize=14, pad=15)
plt.tight_layout()
plt.show()

L'utilisation du masque triangulaire (mask) évite la redondance de la matrice symétrique, et le colormap RdBu_r centré sur zéro rend les corrélations positives et négatives immédiatement identifiables. Petit truc que j'ai appris à la dure : n'oubliez pas de centrer sur 0 avec le paramètre center, sinon vos couleurs seront trompeuses.

Pairplot : Explorer les Relations Multivariées

Le pairplot est l'outil parfait pour l'exploration initiale d'un jeu de données. Il affiche toutes les combinaisons de variables deux à deux, avec la distribution de chaque variable sur la diagonale :

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
import pandas as pd

# Charger le jeu de données Iris
iris = load_iris()
df_iris = pd.DataFrame(iris.data, columns=iris.feature_names)
df_iris["espece"] = pd.Categorical.from_codes(
    iris.target, iris.target_names
)

# Pairplot avec distinction par espèce
g = sns.pairplot(df_iris, hue="espece", palette="husl",
                 diag_kind="kde", plot_kws={"alpha": 0.6, "s": 40})
g.figure.suptitle("Exploration du Jeu de Données Iris",
                  y=1.02, fontsize=14)
plt.show()

En un seul appel de fonction, vous obtenez une vue d'ensemble complète des relations entre toutes les variables, segmentées par catégorie. Honnêtement, c'est souvent le tout premier graphique que je crée quand je découvre un nouveau jeu de données.

L'Interface Objects : L'Avenir de Seaborn

L'interface seaborn.objects, introduite dans la version 0.12, représente une refonte majeure. Inspirée de la grammaire des graphiques (à la ggplot2 en R), elle propose une approche déclarative et composable :

import seaborn.objects as so
import pandas as pd
import numpy as np

# Données simulées
np.random.seed(42)
df = pd.DataFrame({
    "mois": pd.date_range("2025-01", periods=24, freq="ME"),
    "revenus": np.cumsum(np.random.normal(5, 3, 24)) + 100,
    "region": ["Nord"] * 12 + ["Sud"] * 12
})

# Construction déclarative du graphique
(
    so.Plot(df, x="mois", y="revenus", color="region")
    .add(so.Line(linewidth=2))
    .add(so.Dot(pointsize=6))
    .label(
        title="Évolution des Revenus par Région",
        x="Mois",
        y="Revenus (k€)"
    )
    .theme({"axes.grid": True, "grid.alpha": 0.3})
    .show()
)

Cette syntaxe est nettement plus lisible que l'approche traditionnelle. Chaque élément — ligne, point, étiquette, thème — est ajouté de manière indépendante, ce qui facilite beaucoup l'expérimentation. C'est vraiment le genre de syntaxe qui donne envie de jouer avec ses données.

Paramètre native_scale pour les Données Catégorielles

Depuis la version 0.13, les fonctions catégorielles prennent en charge le paramètre native_scale. Ce paramètre permet de traiter les données numériques comme telles, au lieu de les convertir systématiquement en catégories :

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

np.random.seed(42)
df = pd.DataFrame({
    "taille_equipe": np.random.choice([5, 10, 15, 20, 30, 50], 200),
    "bugs_par_sprint": np.random.poisson(lam=10, size=200)
})

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Sans native_scale : espacement régulier
sns.boxplot(data=df, x="taille_equipe", y="bugs_par_sprint",
            ax=axes[0])
axes[0].set_title("Sans native_scale (défaut)")

# Avec native_scale : espacement proportionnel
sns.boxplot(data=df, x="taille_equipe", y="bugs_par_sprint",
            native_scale=True, ax=axes[1])
axes[1].set_title("Avec native_scale=True")

plt.suptitle("Impact du Paramètre native_scale",
             fontsize=14, fontweight="bold")
plt.tight_layout()
plt.show()

Avec native_scale=True, l'espacement entre les valeurs 5, 10, 15, 20, 30, 50 est proportionnel à leur valeur réelle. Le résultat est une représentation bien plus fidèle de la relation entre les variables — et ça peut changer complètement l'interprétation d'un graphique.

Plotly : L'Interactivité au Premier Plan

Plotly, c'est la bibliothèque qui a démocratisé la visualisation interactive en Python. Avec plus de 500 millions de téléchargements cumulés sur PyPI et une version 6.5 sortie début 2026, elle s'est imposée comme la référence pour les graphiques interactifs.

Pourquoi Choisir Plotly ?

La grande force de Plotly, c'est que tout est interactif par défaut. Zoom, survol, sélection, filtrage — tout est intégré nativement, sans écrire une seule ligne de JavaScript. Les graphiques fonctionnent dans Jupyter, en tant que fichiers HTML autonomes, ou intégrés dans des applications Dash. C'est assez bluffant quand on y pense.

Installation et Premier Graphique Interactif

# Installation de Plotly
pip install plotly

# Pour le support Jupyter
pip install nbformat

import plotly.express as px
import pandas as pd
import numpy as np

# Données de ventes simulées
np.random.seed(42)
df = pd.DataFrame({
    "mois": pd.date_range("2024-01", periods=24, freq="ME"),
    "ventes": np.cumsum(np.random.normal(10, 5, 24)) + 200,
    "region": (["Île-de-France"] * 8 + ["Occitanie"] * 8
               + ["Bretagne"] * 8),
    "categorie": np.random.choice(
        ["Électronique", "Textile", "Alimentaire"], 24
    )
})

# Graphique interactif avec Plotly Express
fig = px.line(df, x="mois", y="ventes", color="region",
              title="Évolution des Ventes par Région",
              labels={"mois": "Mois", "ventes": "Ventes (k€)",
                      "region": "Région"},
              template="plotly_white")

fig.update_layout(
    font=dict(size=13),
    hovermode="x unified",
    legend=dict(orientation="h", yanchor="bottom",
                y=1.02, xanchor="right", x=1)
)
fig.show()

En quelques lignes seulement, on obtient un graphique interactif complet : survolez les points pour voir les valeurs, zoomez sur une période, double-cliquez pour réinitialiser. Le tout sans configuration supplémentaire. Difficile de revenir en arrière une fois qu'on y a goûté.

Graphiques Statistiques Interactifs

Plotly Express propose des fonctions de haut niveau pour les graphiques statistiques les plus courants. Voici un exemple qui encode pas moins de quatre dimensions dans un seul scatter plot :

import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np

np.random.seed(42)
n = 300
df = pd.DataFrame({
    "experience": np.random.randint(0, 20, n),
    "salaire": np.random.normal(50000, 15000, n),
    "departement": np.random.choice(
        ["Tech", "Finance", "Marketing", "Opérations"], n
    ),
    "satisfaction": np.random.uniform(3, 10, n),
    "performances": np.random.uniform(50, 100, n)
})
df["salaire"] = df["salaire"] + df["experience"] * 2000

# Scatter plot interactif avec taille et couleur
fig = px.scatter(df, x="experience", y="salaire",
                 color="departement",
                 size="performances",
                 hover_data=["satisfaction"],
                 title="Salaire vs Expérience par Département",
                 labels={"experience": "Années d'Expérience",
                         "salaire": "Salaire Annuel (€)",
                         "departement": "Département"},
                 template="plotly_white",
                 opacity=0.7)

fig.update_layout(font=dict(size=12))
fig.show()

La position x montre l'expérience, y le salaire, la couleur le département, et la taille les performances. Au survol, la satisfaction s'affiche également. Reproduire ça de manière interactive avec Matplotlib seul serait... disons, un sacré défi.

Graphiques Financiers : Chandeliers et OHLC

Plotly 6.x a amélioré le support des graphiques financiers, notamment avec l'ajout de hovertemplate pour les chandeliers et les graphiques OHLC :

import plotly.graph_objects as go
import pandas as pd
import numpy as np

# Simuler des données boursières
np.random.seed(42)
dates = pd.date_range("2025-06-01", periods=60, freq="B")
prix_base = 150
variations = np.random.normal(0, 2, 60).cumsum()
prix = prix_base + variations

df_bourse = pd.DataFrame({
    "date": dates,
    "open": prix + np.random.uniform(-1, 1, 60),
    "high": prix + np.abs(np.random.normal(0, 2, 60)),
    "low": prix - np.abs(np.random.normal(0, 2, 60)),
    "close": prix + np.random.uniform(-1, 1, 60),
    "volume": np.random.randint(100000, 500000, 60)
})

# Graphique en chandeliers
fig = go.Figure(data=[go.Candlestick(
    x=df_bourse["date"],
    open=df_bourse["open"],
    high=df_bourse["high"],
    low=df_bourse["low"],
    close=df_bourse["close"],
    increasing_line_color="#26A69A",
    decreasing_line_color="#EF5350"
)])

fig.update_layout(
    title="Cours de l'Action — Été 2025",
    yaxis_title="Prix (€)",
    xaxis_rangeslider_visible=True,
    template="plotly_white",
    font=dict(size=12)
)
fig.show()

Le slider de plage intégré permet de zoomer sur une période spécifique, et le survol affiche tous les prix de la journée. C'est le type de graphique qui rend Plotly quasi indispensable pour l'analyse financière.

Cartes et Données Géographiques

Plotly offre aussi un excellent support pour la visualisation géographique. Cartes choroplèthes, cartes à points — tout y est :

import plotly.express as px
import pandas as pd

# Données de population par pays européens
df_europe = pd.DataFrame({
    "pays": ["France", "Allemagne", "Espagne", "Italie",
             "Pologne", "Pays-Bas", "Belgique", "Portugal",
             "Suède", "Autriche"],
    "code_iso": ["FRA", "DEU", "ESP", "ITA", "POL",
                 "NLD", "BEL", "PRT", "SWE", "AUT"],
    "pib_par_hab": [42000, 48000, 30000, 34000, 17000,
                    53000, 47000, 24000, 52000, 50000],
    "population_m": [68, 84, 47, 60, 38, 18, 12, 10, 10, 9]
})

fig = px.choropleth(
    df_europe,
    locations="code_iso",
    color="pib_par_hab",
    hover_name="pays",
    hover_data={"population_m": True, "code_iso": False},
    color_continuous_scale="Viridis",
    scope="europe",
    title="PIB par Habitant en Europe (€)",
    labels={"pib_par_hab": "PIB/hab (€)",
            "population_m": "Population (M)"}
)

fig.update_layout(
    geo=dict(showframe=False, showcoastlines=True),
    font=dict(size=12)
)
fig.show()

Tableaux de Bord avec Sous-Graphiques

Plotly permet aussi de créer des compositions multi-graphiques grâce à make_subplots. C'est un peu le couteau suisse du dashboard rapide :

from plotly.subplots import make_subplots
import plotly.graph_objects as go
import numpy as np

np.random.seed(42)
mois = ["Jan", "Fév", "Mar", "Avr", "Mai", "Jun",
        "Jul", "Aoû", "Sep", "Oct", "Nov", "Déc"]
ventes = np.random.randint(80, 200, 12)
objectifs = np.full(12, 140)

fig = make_subplots(
    rows=2, cols=2,
    subplot_titles=("Ventes vs Objectifs", "Répartition Clients",
                    "Tendance Satisfaction", "Top Produits"),
    specs=[[{"type": "bar"}, {"type": "pie"}],
           [{"type": "scatter"}, {"type": "bar"}]]
)

# Ventes vs Objectifs
fig.add_trace(go.Bar(x=mois, y=ventes, name="Ventes",
                     marker_color="#2196F3"), row=1, col=1)
fig.add_trace(go.Scatter(x=mois, y=objectifs, name="Objectif",
                         line=dict(color="red", dash="dash")),
              row=1, col=1)

# Répartition clients
fig.add_trace(go.Pie(
    labels=["Particuliers", "PME", "Grands Comptes", "Institutions"],
    values=[45, 30, 15, 10],
    marker_colors=["#2196F3", "#4CAF50", "#FF9800", "#9C27B0"]
), row=1, col=2)

# Satisfaction
satisfaction = np.random.uniform(7, 9.5, 12)
fig.add_trace(go.Scatter(
    x=mois, y=satisfaction, mode="lines+markers",
    name="Satisfaction", line=dict(color="#4CAF50")
), row=2, col=1)

# Top produits
produits = ["Prod A", "Prod B", "Prod C", "Prod D", "Prod E"]
ventes_prod = [250, 180, 160, 120, 90]
fig.add_trace(go.Bar(
    x=produits, y=ventes_prod, name="Ventes Produits",
    marker_color="#FF9800"
), row=2, col=2)

fig.update_layout(
    height=700, showlegend=True,
    title_text="Dashboard Commercial — Année 2025",
    template="plotly_white"
)
fig.show()

Chaque sous-graphique conserve ses capacités interactives : zoom, survol, export en image. Une alternative élégante aux dashboards construits à la main en HTML/CSS.

Comparaison : Quand Utiliser Chaque Bibliothèque

Bon, avec trois outils dans votre arsenal, la question naturelle c'est : lequel choisir pour quel usage ? Voici un guide pratique basé sur l'expérience terrain.

Matplotlib : Le Choix pour la Publication

Choisissez Matplotlib quand vous avez besoin de :

Un contrôle pixel-parfait sur chaque élément du graphique
Des graphiques pour des publications scientifiques (articles, thèses, rapports)
Des animations via le module animation
Des graphiques 3D avec mpl_toolkits.mplot3d
Une compatibilité maximale avec l'écosystème scientifique Python

Seaborn : Le Choix pour l'Analyse Statistique

Privilégiez Seaborn quand :

Vous faites de l'analyse exploratoire sur des DataFrames
Vous avez besoin de graphiques statistiques élégants (distributions, régressions, corrélations)
Vous voulez un rendu esthétique avec un minimum de configuration
Vous travaillez avec des données catégorielles multiples
Vous préparez des rapports analytiques internes

Plotly : Le Choix pour l'Interactivité

Optez pour Plotly quand :

Vous créez des tableaux de bord interactifs ou des applications web
Les utilisateurs doivent pouvoir explorer les données eux-mêmes
Vous présentez des résultats à des parties prenantes non techniques
Vous travaillez avec des données géographiques
Vous construisez des applications Dash pour la mise en production

Tableau Comparatif

Voici un résumé rapide des caractéristiques clés :

Courbe d'apprentissage : Matplotlib (modérée) — Seaborn (facile) — Plotly (facile)
Interactivité : Matplotlib (limitée) — Seaborn (limitée) — Plotly (native)
Esthétique par défaut : Matplotlib (basique) — Seaborn (excellente) — Plotly (excellente)
Personnalisation : Matplotlib (maximale) — Seaborn (bonne) — Plotly (bonne)
Graphiques 3D : Matplotlib (oui) — Seaborn (non) — Plotly (oui, interactifs)
Export web : Matplotlib (image) — Seaborn (image) — Plotly (HTML interactif)

Techniques Avancées : Combiner les Trois Bibliothèques

En pratique, les data scientists expérimentés ne se limitent pas à une seule bibliothèque. Et franchement, c'est la bonne approche. L'idée, c'est de combiner les forces de chacune selon le contexte.

Workflow Type en Data Science

Voici un workflow courant qui exploite les trois bibliothèques dans un même projet :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

# 1. Charger les données
np.random.seed(42)
n = 1000
df = pd.DataFrame({
    "age": np.random.normal(40, 12, n).clip(18, 70).astype(int),
    "revenu": np.random.lognormal(10.5, 0.5, n),
    "score_credit": np.random.normal(650, 80, n).clip(300, 850).astype(int),
    "montant_pret": np.random.lognormal(11, 0.8, n),
    "defaut": np.random.binomial(1, 0.15, n),
    "region": np.random.choice(
        ["Nord", "Sud", "Est", "Ouest", "Centre"], n
    )
})

# 2. Seaborn pour l'exploration rapide
# Matrice de corrélation des variables numériques
fig, ax = plt.subplots(figsize=(8, 6))
numeriques = df.select_dtypes(include=[np.number])
sns.heatmap(numeriques.corr(), annot=True, fmt=".2f",
            cmap="coolwarm", center=0, ax=ax)
ax.set_title("Corrélations — Données de Crédit")
plt.tight_layout()
plt.savefig("exploration_correlation.png", dpi=150)
plt.show()

# 3. Matplotlib pour le rapport détaillé
fig, axes = plt.subplots(1, 3, figsize=(16, 5))

axes[0].hist(df["score_credit"], bins=30, color="#2196F3",
             edgecolor="white", alpha=0.8)
axes[0].set_title("Distribution Score Crédit")
axes[0].set_xlabel("Score")

sns.kdeplot(data=df, x="revenu", hue="defaut", ax=axes[1],
            fill=True, alpha=0.4)
axes[1].set_title("Revenu par Statut de Défaut")

axes[2].bar(["Non-Défaut", "Défaut"],
            [df["defaut"].value_counts()[0],
             df["defaut"].value_counts()[1]],
            color=["#4CAF50", "#F44336"])
axes[2].set_title("Répartition des Défauts")

plt.tight_layout()
plt.savefig("rapport_credit.png", dpi=150)
plt.show()

# 4. Plotly pour le dashboard interactif destiné aux décideurs
fig = px.scatter(df, x="revenu", y="montant_pret",
                 color="region", symbol="defaut",
                 opacity=0.6,
                 title="Analyse de Risque Crédit — Vue Interactive",
                 labels={"revenu": "Revenu Annuel (€)",
                         "montant_pret": "Montant du Prêt (€)"},
                 template="plotly_white")
fig.write_html("dashboard_credit.html")
fig.show()

Ce workflow illustre une pratique courante et éprouvée : Seaborn pour l'exploration initiale, Matplotlib pour les rapports formatés, et Plotly pour les présentations interactives. Chaque outil joue son rôle, et le résultat final est bien meilleur que ce qu'on obtiendrait avec un seul.

Personnaliser les Thèmes Globalement

Pour garder une cohérence visuelle dans vos projets (et ça, ça fait vraiment la différence), il est utile de définir un thème global partagé entre Matplotlib et Seaborn :

import matplotlib.pyplot as plt
import seaborn as sns

# Définir un style cohérent
sns.set_theme(style="whitegrid", palette="muted",
              font_scale=1.1)

# Personnaliser les paramètres Matplotlib
plt.rcParams.update({
    "figure.figsize": (10, 6),
    "figure.dpi": 100,
    "axes.titlesize": 14,
    "axes.labelsize": 12,
    "font.family": "sans-serif",
    "axes.spines.top": False,
    "axes.spines.right": False,
})

# Tous les graphiques suivants hériteront de ces paramètres

Bonnes Pratiques de Visualisation en 2026

Au-delà des outils, la qualité d'une visualisation dépend aussi du respect de certains principes fondamentaux. Ce sont eux qui font la différence entre un graphique amateur et une visualisation pro.

1. Choisir le Bon Type de Graphique

Chaque type de graphique a un usage précis. Utiliser un camembert pour comparer des valeurs proches ? Erreur classique — un diagramme en barres serait bien plus lisible. Voici les règles de base :

Évolution temporelle : graphique en ligne
Comparaison entre catégories : diagramme en barres
Distribution : histogramme, violin plot, ou KDE
Corrélation : nuage de points (scatter)
Proportions : barres empilées (éviter les camemberts au-delà de 4 catégories)
Données géographiques : cartes choroplèthes ou à bulles

2. L'Accessibilité Avant Tout

Environ 8 % de la population masculine est touchée par le daltonisme. Utilisez le cycle petroff10 de Matplotlib 3.10 ou des palettes accessibles comme colorblind de Seaborn. Ajoutez des marqueurs distincts en plus de la couleur, et assurez un contraste suffisant avec le fond. C'est le genre de détail qui montre qu'on pense à son audience.

3. Simplifier et Désencombrer

Le ratio données/encre, concept popularisé par Edward Tufte, reste le principe directeur : maximisez la proportion d'encre qui représente effectivement des données. Supprimez les bordures inutiles, réduisez les grilles, et surtout, évitez les effets 3D purement décoratifs.

import matplotlib.pyplot as plt

# Style épuré, recommandé en 2026
fig, ax = plt.subplots(figsize=(8, 5))

donnees = [42, 38, 35, 28, 22]
etiquettes = ["Python", "R", "SQL", "Julia", "Scala"]

bars = ax.barh(etiquettes, donnees, color="#2196F3", height=0.6)
ax.bar_label(bars, padding=5, fontsize=11)

ax.set_xlabel("Popularité (%)")
ax.set_title("Langages les Plus Utilisés en Data Science (2026)",
             pad=15)

# Supprimer les bordures inutiles
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.xaxis.set_visible(False)

plt.tight_layout()
plt.show()

4. Annoter pour Raconter une Histoire

Les annotations transforment un simple graphique en récit. Mettez en évidence les points clés, les anomalies, les tendances — c'est ce qui donne du sens à vos visuels :

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)
jours = np.arange(1, 31)
utilisateurs = np.cumsum(np.random.normal(50, 30, 30)) + 1000

fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(jours, utilisateurs, color="#2196F3", linewidth=2)
ax.fill_between(jours, utilisateurs, alpha=0.1, color="#2196F3")

# Annoter un pic
pic_idx = np.argmax(utilisateurs)
ax.annotate(
    f"Pic : {utilisateurs[pic_idx]:.0f} utilisateurs",
    xy=(jours[pic_idx], utilisateurs[pic_idx]),
    xytext=(jours[pic_idx] + 3, utilisateurs[pic_idx] + 100),
    arrowprops=dict(arrowstyle="->", color="#333"),
    fontsize=11, fontweight="bold"
)

ax.set_title("Croissance des Utilisateurs — Janvier 2026")
ax.set_xlabel("Jour")
ax.set_ylabel("Utilisateurs Actifs")
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
plt.tight_layout()
plt.show()

Conclusion : Votre Boîte à Outils de Visualisation en 2026

La visualisation de données en Python n'a jamais été aussi riche et accessible. Matplotlib 3.10 continue d'évoluer avec ses nouveaux colormaps accessibles et son support free-threaded. Seaborn 0.13 offre une interface renouvelée avec son API objects et ses fonctions catégorielles améliorées. Et Plotly 6.5 repousse les limites de l'interactivité.

La clé, ce n'est pas de tout maîtriser sur le bout des doigts. C'est de savoir quand utiliser quoi. Matplotlib pour la précision et la publication, Seaborn pour l'élégance statistique, Plotly pour l'interactivité et la présentation. Ensemble, ces trois bibliothèques couvrent la quasi-totalité des besoins d'un data scientist.

Et surtout, n'oubliez pas que l'objectif final d'une visualisation n'est pas d'impressionner par sa complexité technique. C'est de communiquer clairement un message. Le meilleur graphique, au fond, c'est celui que son audience comprend immédiatement — sans avoir besoin d'explication.