Matplotlib

Aperçu

Matplotlib est la bibliothèque de visualisation fondamentale de Python pour créer des graphiques statiques, animés et interactifs. Cette compétence fournit des conseils pour utiliser matplotlib efficacement, couvrant à la fois l'interface pyplot (style MATLAB) et l'API orientée objet (Figure/Axes), ainsi que les bonnes pratiques pour créer des visualisations de qualité publication.

Quand utiliser cette compétence

Cette compétence doit être utilisée quand :

Créer n'importe quel type de graphique ou diagramme (ligne, nuage de points, barres, histogramme, heatmap, contour, etc.)
Générer des visualisations scientifiques ou statistiques
Personnaliser l'apparence des graphiques (couleurs, styles, étiquettes, légendes)
Créer des figures multi-panneaux avec des sous-graphiques
Exporter des visualisations vers divers formats (PNG, PDF, SVG, etc.)
Construire des graphiques interactifs ou des animations
Travailler avec des visualisations 3D
Intégrer des graphiques dans les notebooks Jupyter ou les applications GUI

Concepts fondamentaux

La hiérarchie Matplotlib

Matplotlib utilise une structure hiérarchique d'objets :

Figure - Le conteneur de haut niveau pour tous les éléments du graphique
Axes - La zone de traçage réelle où les données sont affichées (une Figure peut contenir plusieurs Axes)
Artist - Tout ce qui est visible sur la figure (lignes, texte, graduations, etc.)
Axis - Les objets de droite numérique (axe x, axe y) qui gèrent les graduations et les étiquettes

Deux interfaces

1. Interface pyplot (Implicite, style MATLAB)

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Pratique pour les graphiques simples et rapides
Maintient l'état automatiquement
Bien pour le travail interactif et les scripts simples

2. Interface orientée objet (Explicite)

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4])
ax.set_ylabel('some numbers')
plt.show()

Recommandée pour la plupart des cas d'usage
Contrôle plus explicite sur la figure et les axes
Mieux pour les figures complexes avec plusieurs sous-graphiques
Plus facile à maintenir et déboguer

Workflows courants

1. Création de graphique de base

Workflow avec un seul graphique :

import matplotlib.pyplot as plt
import numpy as np

# Create figure and axes (OO interface - RECOMMENDED)
fig, ax = plt.subplots(figsize=(10, 6))

# Generate and plot data
x = np.linspace(0, 2*np.pi, 100)
ax.plot(x, np.sin(x), label='sin(x)')
ax.plot(x, np.cos(x), label='cos(x)')

# Customize
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Trigonometric Functions')
ax.legend()
ax.grid(True, alpha=0.3)

# Save and/or display
plt.savefig('plot.png', dpi=300, bbox_inches='tight')
plt.show()

2. Sous-graphiques multiples

Création de dispositions de sous-graphiques :

# Method 1: Regular grid
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
axes[0, 0].plot(x, y1)
axes[0, 1].scatter(x, y2)
axes[1, 0].bar(categories, values)
axes[1, 1].hist(data, bins=30)

# Method 2: Mosaic layout (more flexible)
fig, axes = plt.subplot_mosaic([['left', 'right_top'],
                                 ['left', 'right_bottom']],
                                figsize=(10, 8))
axes['left'].plot(x, y)
axes['right_top'].scatter(x, y)
axes['right_bottom'].hist(data)

# Method 3: GridSpec (maximum control)
from matplotlib.gridspec import GridSpec
fig = plt.figure(figsize=(12, 8))
gs = GridSpec(3, 3, figure=fig)
ax1 = fig.add_subplot(gs[0, :])  # Top row, all columns
ax2 = fig.add_subplot(gs[1:, 0])  # Bottom two rows, first column
ax3 = fig.add_subplot(gs[1:, 1:])  # Bottom two rows, last two columns

3. Types de graphiques et cas d'usage

Graphiques en lignes - Séries temporelles, données continues, tendances

ax.plot(x, y, linewidth=2, linestyle='--', marker='o', color='blue')

Nuages de points - Relations entre variables, corrélations

ax.scatter(x, y, s=sizes, c=colors, alpha=0.6, cmap='viridis')

Diagrammes en barres - Comparaisons catégoriques

ax.bar(categories, values, color='steelblue', edgecolor='black')
# For horizontal bars:
ax.barh(categories, values)

Histogrammes - Distributions

ax.hist(data, bins=30, edgecolor='black', alpha=0.7)

Heatmaps - Données matricielles, corrélations

im = ax.imshow(matrix, cmap='coolwarm', aspect='auto')
plt.colorbar(im, ax=ax)

Graphiques de contour - Données 3D sur plan 2D

contour = ax.contour(X, Y, Z, levels=10)
ax.clabel(contour, inline=True, fontsize=8)

Boîtes à moustaches - Distributions statistiques

ax.boxplot([data1, data2, data3], labels=['A', 'B', 'C'])

Graphiques en violon - Densités de distribution

ax.violinplot([data1, data2, data3], positions=[1, 2, 3])

Pour des exemples et variations complets de types de graphiques, consultez references/plot_types.md.

4. Style et personnalisation

Méthodes de spécification des couleurs :

Couleurs nommées : 'red', 'blue', 'steelblue'
Codes hexadécimaux : '#FF5733'
Tuples RGB : (0.1, 0.2, 0.3)
Colormaps : cmap='viridis', cmap='plasma', cmap='coolwarm'

Utilisation de feuilles de style :

plt.style.use('seaborn-v0_8-darkgrid')  # Apply predefined style
# Available styles: 'ggplot', 'bmh', 'fivethirtyeight', etc.
print(plt.style.available)  # List all available styles

Personnalisation avec rcParams :

plt.rcParams['font.size'] = 12
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['axes.titlesize'] = 16
plt.rcParams['xtick.labelsize'] = 10
plt.rcParams['ytick.labelsize'] = 10
plt.rcParams['legend.fontsize'] = 12
plt.rcParams['figure.titlesize'] = 18

Texte et annotations :

ax.text(x, y, 'annotation', fontsize=12, ha='center')
ax.annotate('important point', xy=(x, y), xytext=(x+1, y+1),
            arrowprops=dict(arrowstyle='->', color='red'))

Pour des options de style détaillées et des directives de colormap, consultez references/styling_guide.md.

5. Sauvegarde de figures

Export vers divers formats :

# High-resolution PNG for presentations/papers
plt.savefig('figure.png', dpi=300, bbox_inches='tight', facecolor='white')

# Vector format for publications (scalable)
plt.savefig('figure.pdf', bbox_inches='tight')
plt.savefig('figure.svg', bbox_inches='tight')

# Transparent background
plt.savefig('figure.png', dpi=300, bbox_inches='tight', transparent=True)

Paramètres importants :

dpi : Résolution (300 pour les publications, 150 pour le web, 72 pour l'écran)
bbox_inches='tight' : Supprime l'espace blanc excessif
facecolor='white' : Garantit un fond blanc (utile pour les thèmes transparents)
transparent=True : Fond transparent

6. Travail avec des graphiques 3D

from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

# Surface plot
ax.plot_surface(X, Y, Z, cmap='viridis')

# 3D scatter
ax.scatter(x, y, z, c=colors, marker='o')

# 3D line plot
ax.plot(x, y, z, linewidth=2)

# Labels
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

Bonnes pratiques

1. Sélection de l'interface

Utilisez l'interface orientée objet (fig, ax = plt.subplots()) pour le code de production
Réservez l'interface pyplot pour l'exploration interactive rapide uniquement
Créez toujours les figures explicitement plutôt que de compter sur l'état implicite

2. Taille de la figure et DPI

Définissez figsize à la création : fig, ax = plt.subplots(figsize=(10, 6))
Utilisez le DPI approprié pour le medium de sortie :
- Écran/notebook : 72-100 dpi
- Web : 150 dpi
- Impression/publications : 300 dpi

3. Gestion de la mise en page

Utilisez constrained_layout=True ou tight_layout() pour éviter les éléments qui se chevauchent
fig, ax = plt.subplots(constrained_layout=True) est recommandé pour l'espacement automatique

4. Sélection de colormap

Séquentielle (viridis, plasma, inferno) : Données ordonnées avec progression cohérente
Divergente (coolwarm, RdBu) : Données avec centre significatif (ex. zéro)
Qualitative (tab10, Set3) : Données catégoriques/nominales
Évitez les colormaps arc-en-ciel (jet) - elles ne sont pas perceptuellement uniformes

5. Accessibilité

Utilisez des colormaps adaptées aux daltoniens (viridis, cividis)
Ajoutez des motifs/hachures pour les diagrammes en barres en plus des couleurs
Assurez un contraste suffisant entre les éléments
Incluez des étiquettes et des légendes descriptives

6. Performance

Pour les grands ensembles de données, utilisez rasterized=True dans les appels de traçage pour réduire la taille du fichier
Utilisez la réduction de données appropriée avant le traçage (ex. réduire les séries temporelles denses)
Pour les animations, utilisez le blitting pour une meilleure performance

7. Organisation du code

# Good practice: Clear structure
def create_analysis_plot(data, title):
    """Create standardized analysis plot."""
    fig, ax = plt.subplots(figsize=(10, 6), constrained_layout=True)

    # Plot data
    ax.plot(data['x'], data['y'], linewidth=2)

    # Customize
    ax.set_xlabel('X Axis Label', fontsize=12)
    ax.set_ylabel('Y Axis Label', fontsize=12)
    ax.set_title(title, fontsize=14, fontweight='bold')
    ax.grid(True, alpha=0.3)

    return fig, ax

# Use the function
fig, ax = create_analysis_plot(my_data, 'My Analysis')
plt.savefig('analysis.png', dpi=300, bbox_inches='tight')

Scripts de référence rapide

Cette compétence inclut des scripts d'aide dans le répertoire scripts/ :

`plot_template.py`

Script de modèle démontrant divers types de graphiques avec les bonnes pratiques. Utilisez-le comme point de départ pour créer de nouvelles visualisations.

Utilisation :

python scripts/plot_template.py

`style_configurator.py`

Utilitaire interactif pour configurer les préférences de style matplotlib et générer des feuilles de style personnalisées.