Creer des graphiques multiples avec axes partages en Python Matplotlib

Introduction : Pourquoi utiliser des axes multiples ?

Dans le monde de la visualisation de donnees, il est frequent de devoir comparer des grandeurs ayant des echelles tres differentes. Imaginez vouloir afficher sur un meme graphique la temperature (en degres Celsius) et les precipitations (en millimetres), ou encore le prix d’une action et son volume d’echanges. Sans axes multiples, l’une des courbes serait ecrasee par l’echelle de l’autre.

Les fonctions twinx() et twiny() de Matplotlib resolvent elegamment ce probleme en permettant de superposer plusieurs axes sur un meme graphique. Cette technique est particulierement utilisee dans :

• La finance : comparaison prix/volume, indicateurs techniques
• La meteorologie : temperature/precipitations, pression/humidite
• L’ingenierie : tension/courant, vitesse/acceleration
• La recherche scientifique : correlation entre variables de differentes unites

Dans ce tutoriel approfondi, nous allons maitriser ces outils essentiels pour creer des visualisations professionnelles.

Comprendre twinx() : Deux axes Y sur un axe X commun

La fonction twinx() cree un nouvel axe Y qui partage le meme axe X que l’axe original. C’est la configuration la plus courante pour comparer deux series temporelles ou deux variables dependant de la meme variable independante.

Exemple de base

import numpy as np
import matplotlib.pyplot as plt

# Generation des donnees
x = np.linspace(0, 2.0*np.pi, 101)
y = np.sin(x)          # Oscillation bornee [-1, 1]
z = np.sinh(x)         # Croissance exponentielle

# Creation de la figure et du premier axe
fig, ax1 = plt.subplots(figsize=(10, 6))

# Creation du second axe partageant le meme X
ax2 = ax1.twinx()

# Tracage des courbes avec des couleurs distinctes
curve1, = ax1.plot(x, y, label="sin(x)", color='r', linewidth=2)
curve2, = ax2.plot(x, z, label="sinh(x)", color='b', linewidth=2)

# Configuration des axes
ax1.set_xlabel('x (radians)', fontsize=12)
ax1.set_ylabel('sin(x)', color='r', fontsize=12)
ax2.set_ylabel('sinh(x)', color='b', fontsize=12)

# Coloration des ticks pour correspondre aux courbes
ax1.tick_params(axis='y', labelcolor='r')
ax2.tick_params(axis='y', labelcolor='b')

# Legende combinee
curves = [curve1, curve2]
ax1.legend(curves, [curve.get_label() for curve in curves], loc='upper left')

plt.title("Comparaison sin(x) et sinh(x) avec axes Y distincts", fontsize=14)
plt.tight_layout()
plt.show()

Exemple avance : Donnees financieres

import numpy as np
import matplotlib.pyplot as plt

# Simulation de donnees financieres
np.random.seed(42)
jours = np.arange(1, 31)
prix = 100 + np.cumsum(np.random.randn(30) * 2)  # Prix de l'action
volume = np.random.randint(1000, 5000, 30)       # Volume d'echanges

fig, ax1 = plt.subplots(figsize=(12, 6))
ax2 = ax1.twinx()

# Prix en ligne
line_prix = ax1.plot(jours, prix, 'b-', linewidth=2, label='Prix ($)')
ax1.fill_between(jours, prix, alpha=0.1, color='blue')

# Volume en barres
bars_volume = ax2.bar(jours, volume, alpha=0.3, color='green', label='Volume')

# Configuration des axes
ax1.set_xlabel('Jour du mois', fontsize=12)
ax1.set_ylabel('Prix ($)', color='blue', fontsize=12)
ax2.set_ylabel('Volume', color='green', fontsize=12)

ax1.tick_params(axis='y', labelcolor='blue')
ax2.tick_params(axis='y', labelcolor='green')

# Legende combinee
lines = line_prix + [bars_volume]
labels = [l.get_label() for l in line_prix] + ['Volume']
ax1.legend(lines, labels, loc='upper left')

plt.title('Analyse Prix/Volume - Action XYZ', fontsize=14)
plt.tight_layout()
plt.show()

Comprendre twiny() : Deux axes X sur un axe Y commun

La fonction twiny() cree un nouvel axe X en haut du graphique, partageant le meme axe Y. Cette configuration est moins courante mais tres utile pour afficher deux echelles differentes pour la meme variable.

Exemple pratique : Conversion d’unites

import numpy as np
import matplotlib.pyplot as plt

# Donnees en Celsius
celsius = np.linspace(-20, 40, 100)
humidity = 50 + 30 * np.sin(celsius * np.pi / 30)  # Humidite simulee

fig, ax1 = plt.subplots(figsize=(10, 6))
ax2 = ax1.twiny()

# Tracage sur l'axe principal (Celsius)
ax1.plot(celsius, humidity, 'b-', linewidth=2)

# Configuration de l'axe secondaire (Fahrenheit)
# Conversion : F = C * 9/5 + 32
fahrenheit_ticks = ax1.get_xticks()
ax2.set_xlim(ax1.get_xlim()[0] * 9/5 + 32, ax1.get_xlim()[1] * 9/5 + 32)

ax1.set_xlabel('Temperature (Celsius)', fontsize=12)
ax2.set_xlabel('Temperature (Fahrenheit)', fontsize=12, color='red')
ax1.set_ylabel('Humidite relative (%)', fontsize=12)

ax2.tick_params(axis='x', labelcolor='red')

plt.title('Humidite en fonction de la temperature', fontsize=14)
plt.tight_layout()
plt.show()

Exemple : Frequence et Periode

import numpy as np
import matplotlib.pyplot as plt

# Spectre de signal
frequence = np.linspace(0.1, 10, 100)  # Hz
amplitude = 1 / (1 + (frequence - 3)**2)  # Resonance a 3 Hz

fig, ax1 = plt.subplots(figsize=(10, 6))
ax2 = ax1.twiny()

ax1.plot(frequence, amplitude, 'purple', linewidth=2)
ax1.fill_between(frequence, amplitude, alpha=0.2, color='purple')

# Configuration des axes
ax1.set_xlabel('Frequence (Hz)', fontsize=12)
ax1.set_ylabel('Amplitude', fontsize=12)

# Axe secondaire : periode (T = 1/f)
ax2.set_xlim(1/ax1.get_xlim()[0], 1/ax1.get_xlim()[1])
ax2.set_xlabel('Periode (s)', fontsize=12, color='orange')
ax2.tick_params(axis='x', labelcolor='orange')

plt.title('Spectre de resonance', fontsize=14)
plt.tight_layout()
plt.show()

Combiner twinx() et twiny() : Quatre axes

Pour des visualisations complexes, vous pouvez combiner les deux techniques :

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.exp(x/5)

fig, ax1 = plt.subplots(figsize=(10, 6))

# Creer les axes supplementaires
ax2 = ax1.twinx()
ax3 = ax1.twiny()

# Tracer les donnees
ax1.plot(x, y1, 'r-', linewidth=2, label='sin(x)')
ax2.plot(x, y2, 'b-', linewidth=2, label='exp(x/5)')

# Configuration
ax1.set_xlabel('x (unite A)', fontsize=11)
ax1.set_ylabel('sin(x)', color='red', fontsize=11)
ax2.set_ylabel('exp(x/5)', color='blue', fontsize=11)
ax3.set_xlabel('x (unite B)', fontsize=11, color='green')

ax1.tick_params(axis='y', labelcolor='red')
ax2.tick_params(axis='y', labelcolor='blue')
ax3.tick_params(axis='x', labelcolor='green')

plt.title('Graphique avec axes multiples', fontsize=14)
plt.tight_layout()
plt.show()

Bonnes Pratiques

Voici les recommandations essentielles pour creer des graphiques multi-axes professionnels :

1. Utilisez des couleurs coherentes

Associez toujours la meme couleur a une courbe et son axe correspondant. Cela permet au lecteur d’identifier instantanement quelle echelle utiliser.

2. Ajoutez des etiquettes explicites

Chaque axe doit avoir une etiquette claire avec l’unite de mesure. Ne laissez jamais d’axe sans identification.

3. Limitez le nombre d’axes

Au-dela de deux axes Y (ou deux axes X), le graphique devient difficile a lire. Preferez plusieurs graphiques separes si necessaire.

4. Utilisez tight_layout()

Cette fonction ajuste automatiquement les marges pour eviter que les etiquettes soient coupees.

5. Choisissez le bon type de visualisation

Combinez differents types (lignes, barres, aires) pour differencier visuellement les series de donnees.

Pieges Courants

Evitez ces erreurs frequentes qui peuvent ruiner vos visualisations :

1. Oublier de synchroniser les legendes

Quand vous avez plusieurs axes, la legende doit regrouper toutes les courbes. Utilisez la technique des curves combinee montree dans les exemples.

2. Echelles mal choisies

Si une courbe est presque plate, ajustez manuellement les limites avec set_ylim() ou set_xlim().

3. Superposition illisible

Evitez que les courbes se chevauchent completement. Utilisez la transparence (alpha) ou des styles de ligne differents.

4. Ignorer les daltoniens

Environ 8% de la population masculine est daltonienne. Evitez les combinaisons rouge/vert. Preferez bleu/orange ou utilisez des motifs differents.

# Exemple de style accessible
ax1.plot(x, y1, 'b-', linewidth=2)      # Bleu, ligne continue
ax2.plot(x, y2, 'orange', linestyle='--', linewidth=2)  # Orange, tirets

Conclusion

Les fonctions twinx() et twiny() de Matplotlib sont des outils indispensables pour la visualisation de donnees multi-echelles. En maitrisant ces techniques, vous pouvez :

• Comparer des variables de grandeurs differentes sur un meme graphique
• Creer des visualisations financieres professionnelles
• Afficher plusieurs unites de mesure simultanement
• Produire des graphiques scientifiques de qualite publication

La cle du succes reside dans la clarte : couleurs coherentes, etiquettes explicites et legendes completes. N’hesitez pas a experimenter avec les differentes options de style pour trouver la presentation optimale pour vos donnees.

Pour aller plus loin

Dans les prochains articles, nous explorerons d’autres techniques avancees de Matplotlib :

• Creation de sous-graphiques avec subplots()
• Graphiques 3D avec mplot3d
• Animations avec FuncAnimation
• Export haute resolution pour publications