Formation Data Visualisation Python 2026
Matplotlib · Seaborn · Plotly · Dash — Dashboards interactifs

1. Attributs préattentifs — ce que le cerveau voit avant de lire

Certains attributs visuels sont traités par le cortex visuel avant toute attention consciente : la couleur, l’orientation, la taille, la forme, le mouvement. Un Data Scientist expert exploite ces attributs pour guider l’œil vers l’information critique sans effort cognitif.

• Couleur (teinte) : différencie des catégories sans ordre implicite. Jamais plus de 7–8 couleurs distinctes — au-delà, la discrimination devient impossible.
• Intensité (luminosité) : encode une variable continue ou ordinale. La heatmap exploite cet attribut.
• Taille/longueur : le barplot utilise la longueur — attribut le plus précis pour la comparaison quantitative.
• Position : l’attribut le plus précis de tous. Toujours privilégier un scatterplot à un bubble chart quand deux variables suffisent.

2. Principes de Gestalt appliqués aux dashboards

• Proximité : groupez les graphiques liés — espacement visuel = séparation logique.
• Similarité : même couleur pour le même type d’information dans tous vos graphiques.
• Continuité : l’œil suit les lignes — un lineplot suggère une continuité temporelle même sur des données discrètes.
• Clôture : des formes incomplètes sont perçues comme complètes — exploité dans les jauges et radars.

3. Matrice de décision : quel graphique pour quel objectif ?

4. Le chartjunk — l’ennemi de la clarté

Edward Tufte a formalisé le concept de chartjunk : tout élément visuel qui n’encode pas d’information utile. Règle pratique : supprimez jusqu’à ce que ça fasse mal, puis rajoutez un élément.

• Grilles trop denses — gardez seulement les gridlines majeures en gris clair
• Bordures de graphiques — inutiles dans 90 % des cas
• Légende quand le titre suffit
• Effets 3D sur les barres ou camemberts — déforment les proportions
• Trop de couleurs — une variable = une couleur maximum

1. Profiling rapide d’un dataset inconnu

Avant toute visualisation, on réalise un diagnostic en moins de 10 lignes. Ce pipeline standard permet d’identifier en 2 minutes les problèmes critiques : types incorrects, taux de nullité, doublons, variables à variance nulle.

import pandas as pd
import numpy as np

df = pd.read_csv('dataset.csv')

# Diagnostic en 1 bloc
print(f"Shape : {df.shape}")
print(f"Doublons : {df.duplicated().sum()}")
print("\n--- Nullité ---")
print(df.isnull().sum() / len(df) * 100)

# Types et cardinalité
for col in df.select_dtypes(include='object').columns:
    print(f"{col} : {df[col].nunique()} valeurs uniques")

# Stats descriptives avec percentiles extrêmes
df.describe(percentiles=[.01, .05, .25, .5, .75, .95, .99]).T

2. Détection et traitement des outliers

Deux méthodes complémentaires : la méthode IQR (robuste, non-paramétrique) et le z-score (efficace sur des distributions quasi-normales).

from scipy import stats

# Méthode IQR (Interquartile Range)
def detect_outliers_iqr(series, factor=1.5):
    Q1 = series.quantile(0.25)
    Q3 = series.quantile(0.75)
    IQR = Q3 - Q1
    lower = Q1 - factor * IQR
    upper = Q3 + factor * IQR
    return (series < lower) | (series > upper)

# Application sur toutes les colonnes numériques
numeric_cols = df.select_dtypes(include=['float64', 'int64']).columns
for col in numeric_cols:
    mask = detect_outliers_iqr(df[col])
    print(f"{col} : {mask.sum()} outliers ({mask.mean()*100:.1f}%)")

3. Heatmap de valeurs manquantes avec missingno

import missingno as msno
import matplotlib.pyplot as plt

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

# Matrice de nullité
msno.matrix(df, ax=axes[0], color=(0.25, 0.45, 0.65))
axes[0].set_title('Matrice de nullité')

# Heatmap de corrélation des nullités
msno.heatmap(df, ax=axes[1])
axes[1].set_title('Corrélation des valeurs manquantes')
plt.tight_layout()
plt.show()

4. Agrégations avancées avec groupby et pivot_table

# Agrégation multi-niveaux avec intervalle de confiance
agg_df = (df
    .groupby(['categorie', 'region'])['ventes']
    .agg(['mean', 'std', 'count'])
    .reset_index()
)
agg_df['ci95'] = 1.96 * agg_df['std'] / np.sqrt(agg_df['count'])

# Pivot table pour heatmap
pivot = df.pivot_table(
    values='ventes', index='categorie',
    columns='mois', aggfunc='median', fill_value=0
)

1. L’API orientée objet vs pyplot

L’erreur classique est d’utiliser plt.plot() partout. L’API objet (fig, ax = plt.subplots()) donne un contrôle total et est la norme dans le code de production. Voici un layout complexe avec GridSpec :

import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np

fig = plt.figure(figsize=(14, 8), facecolor='#fafafa')
gs = gridspec.GridSpec(2, 3, figure=fig, hspace=0.35, wspace=0.3)

# Graphique principal sur toute la ligne du haut
ax_main = fig.add_subplot(gs[0, :])
ax1 = fig.add_subplot(gs[1, 0])
ax2 = fig.add_subplot(gs[1, 1])
ax3 = fig.add_subplot(gs[1, 2])

# Courbe avec IC 95%
x = np.linspace(0, 12, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)
ax_main.plot(x, y, color='#2563eb', linewidth=2, label='Ventes')
ax_main.fill_between(x, y - 0.2, y + 0.2, alpha=0.15, color='#2563eb', label='IC 95%')
ax_main.spines['top'].set_visible(False)
ax_main.spines['right'].set_visible(False)
ax_main.grid(axis='y', alpha=0.3, linestyle='--')
ax_main.legend(frameon=False)

2. Twin axes — deux variables sur le même graphique

# Volume (barres) + Prix moyen (courbe) sur le même axe X
fig, ax1 = plt.subplots(figsize=(12, 5))

mois = ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun']
volumes = [1200, 890, 1450, 1100, 1380, 1600]
prix = [45.2, 47.8, 44.1, 48.5, 46.3, 49.2]

ax1.bar(mois, volumes, color='#bfdbfe', alpha=0.7, label='Volume')
ax1.set_ylabel('Volume (unités)', color='#1d4ed8')

ax2 = ax1.twinx()
ax2.plot(mois, prix, 'o-', color='#dc2626', linewidth=2, label='Prix moyen')
ax2.set_ylabel('Prix moyen (€)', color='#dc2626')
fig.suptitle('Volume vs Prix — H1 2025', fontsize=14, fontweight='bold')

3. Annotations et callouts — mettre en valeur l’insight

# Annoter un pic critique avec flèche
max_idx = np.argmax(y)
ax.annotate(
    f'Pic : {y[max_idx]:.2f}',
    xy=(x[max_idx], y[max_idx]),
    xytext=(x[max_idx] + 0.5, y[max_idx] + 0.3),
    fontsize=10, fontweight='bold', color='#dc2626',
    arrowprops=dict(arrowstyle='->', color='#dc2626', lw=1.5)
)

# Ligne de référence (objectif, seuil)
ax.axhline(y=0.8, color='#059669', linestyle='--', linewidth=1.5)
ax.text(0.02, 0.82, 'Objectif', transform=ax.transAxes,
      color='#059669', fontsize=9)

1. Distributions — histplot, kdeplot, ecdfplot

Seaborn 0.12+ a refactorisé ses API de distribution. Voici les trois niveaux d’analyse d’une variable numérique, du plus basique au plus informatif :

import seaborn as sns
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

# Histogramme + KDE superposés
sns.histplot(data=df, x='revenu', kde=True, bins=40,
             color='#3b82f6', ax=axes[0])
axes[0].set_title('Distribution (histplot)')

# KDE par groupe
sns.kdeplot(data=df, x='revenu', hue='segment',
             fill=True, alpha=0.4, ax=axes[1])
axes[1].set_title('KDE par segment')

# ECDF — utile pour lire les percentiles
sns.ecdfplot(data=df, x='revenu', hue='segment', ax=axes[2])
axes[2].axhline(0.5, color='gray', linestyle='--', alpha=0.7)
axes[2].set_title('Distribution cumulée (ECDF)')
plt.tight_layout()

2. Heatmap de corrélation annotée

import numpy as np

# Matrice de corrélation avec masque triangle supérieur
corr_matrix = df.select_dtypes(include='number').corr()
mask = np.triu(np.ones_like(corr_matrix, dtype=bool))

fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(
    corr_matrix, mask=mask, annot=True, fmt='.2f',
    cmap='RdBu_r', center=0, vmin=-1, vmax=1,
    square=True, linewidths=0.5, ax=ax
)
ax.set_title('Corrélations entre variables', fontsize=14, fontweight='bold')

3. FacetGrid — explorer des sous-groupes automatiquement

# Distribution par région et segment en un appel
g = sns.FacetGrid(
    df, col='region', row='segment',
    height=3.5, aspect=1.3, sharex=True, sharey=False
)
g.map_dataframe(sns.histplot, x='revenu', kde=True,
               color='#6366f1', alpha=0.7)
g.set_titles(col_template='{col_name}', row_template='{row_name}')
g.set_axis_labels('Revenu (€)', 'Fréquence')
g.figure.suptitle('Distribution du revenu par région et segment', y=1.02)
plt.tight_layout()

4. Pairplot avancé — EDA multivariée en une ligne

g = sns.pairplot(
    df[['revenu', 'age', 'score', 'segment']],
    hue='segment', diag_kind='kde',
    plot_kws={'alpha': 0.5, 's': 30},
    diag_kws={'fill': True, 'alpha': 0.4},
    palette='Set2'
)
g.figure.suptitle('Analyse multivariée par segment', y=1.02, fontsize=14)

1. Plotly Express vs Graph Objects

plotly.express génère des graphiques interactifs en une ligne avec une API de haut niveau. plotly.graph_objects donne un contrôle total — indispensable pour des graphiques mixtes ou des dashboards complexes.

import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Scatterplot interactif avec régression
fig = px.scatter(
    df, x='revenu', y='score',
    color='segment', size='age',
    hover_data=['region', 'produit'],
    trendline='ols',
    title='Revenu vs Score par segment',
    template='plotly_white'
)
fig.update_layout(title_x=0.5, legend=dict(orientation='h', y=-0.15))
fig.show()

2. Subplots interactifs avec Graph Objects

fig = make_subplots(
    rows=2, cols=2,
    subplot_titles=('Distribution revenus', 'Ventes par région',
                    'Évolution temporelle', 'Score vs Revenu'),
    specs=[[{'type': 'histogram'}, {'type': 'bar'}],
           [{'type': 'scatter'}, {'type': 'scatter'}]]
)
fig.add_trace(go.Histogram(x=df['revenu'], name='Revenus',
                           marker_color='#3b82f6'), row=1, col=1)
fig.add_trace(go.Bar(
    x=df.groupby('region')['ventes'].sum().index,
    y=df.groupby('region')['ventes'].sum().values,
    marker_color='#059669'), row=1, col=2)
fig.update_layout(height=600, showlegend=False,
                  title_text='Dashboard Analytique Q1', title_x=0.5)
fig.show()

3. Animation temporelle

# Évolution dans le temps style Gapminder
fig = px.scatter(
    df_time, x='revenu_median', y='taux_conversion',
    animation_frame='mois', animation_group='segment',
    color='region', size='volume_ventes', size_max=60,
    hover_name='segment',
    range_x=[0, 10000], range_y=[0, 1],
    title='Évolution des segments — Jan → Déc 2024'
)
fig.show()

1. Architecture Dash — layout et callbacks

Dash (par Plotly) permet de créer des applications analytiques interactives en Python pur, sans JavaScript. Un layout définit l’interface, les callbacks connectent les inputs aux outputs et mettent à jour les graphiques en temps réel.

from dash import Dash, dcc, html, Input, Output
import plotly.express as px

app = Dash(__name__)

app.layout = html.Div([
    html.H1('Dashboard Ventes', style={'textAlign': 'center'}),
    dcc.Dropdown(
        id='dropdown-region',
        options=[{'label': r, 'value': r} for r in df['region'].unique()],
        value=None, placeholder='Filtrer par région...', multi=True
    ),
    dcc.RangeSlider(id='slider-mois', min=1, max=12,
                    value=[1, 12], marks={i: str(i) for i in range(1, 13)}),
    dcc.Graph(id='graph-ventes'),
])

@app.callback(
    Output('graph-ventes', 'figure'),
    Input('dropdown-region', 'value'),
    Input('slider-mois', 'value')
)
def update_graph(regions, mois_range):
    filtered = df[df['mois'].between(mois_range[0], mois_range[1])]
    if regions:
        filtered = filtered[filtered['region'].isin(regions)]
    return px.bar(filtered, x='mois', y='ventes',
                  color='region', barmode='group', template='plotly_white')

if __name__ == '__main__':
    app.run(debug=True)

2. Data Storytelling — framework SCR

La visualisation seule ne suffit pas. Un Data Scientist senior structure ses rapports comme un journaliste. Le framework SCR (Situation → Complication → Résolution) :

• Situation — contexte connu de l’audience : « Les ventes ont progressé de 12 % en 2024... »
• Complication — le problème révélé par les données : « ...mais le segment Premium recule de 8 % depuis mars. »
• Résolution — l’insight actionnable : « L’analyse montre une corrélation à −0.72 entre le prix et la conversion — une campagne de réactivation ciblée est recommandée. »

3. Export publication — PDF, HTML, PNG haute résolution

# Matplotlib — PNG haute résolution (presse/publication)
fig.savefig('dashboard.png', dpi=300, bbox_inches='tight', facecolor='white')

# Plotly — HTML interactif (partageable sans serveur)
fig.write_html('rapport.html', include_plotlyjs='cdn')

# PDF multi-pages avec matplotlib
from matplotlib.backends.backend_pdf import PdfPages
with PdfPages('rapport_complet.pdf') as pdf:
    for fig in [fig1, fig2, fig3]:
        pdf.savefig(fig, dpi=200, bbox_inches='tight')
        plt.close(fig)