View Categories

Matplotlib : Fonctionnalités avancées

Ajouter des annotations et du texte pour améliorer les visualisations #

Dans Matplotlib, tu peux incorporer des annotations et du texte en utilisant différentes méthodes. Ceci est très utile lors de présentations, c’est une technique puissante pour améliorer la communication des idées et mettre en évidence les points clés de tes tracés.

  • Ajout de texte à l’aide des fonctions text : La fonction plt.text(x_pos,y_pos,desired_text,fontsize=desired_size) te permet d’ajouter un texte personnalisé à des coordonnées spécifiées sur le graphique.
  • Annoter avec la fonction annotate() : La fonction plt.annotate(desired_text,xy=arrow_pos,xytext=text_post) te permet d’ajouter un texte avec une flèche ou un marqueur associé pointant vers un endroit spécifique du tracé.
  • Étiquetage des points de données : Tu peux étiqueter des points de données individuels dans un nuage de points en utilisant text() ou annotate().
# Exemple de données pour le chiffre d'affaires des magasins de détail
months = ['Jan', 'Fev', 'Mar', 'Avr', 'Mai', 'Juin', 'Juil', 'Aout', 'Sept', 'Oct', 'Nov', 'Dec']
store_locations = ['Magasin A', 'Magasin B']
revenue_data = np.array([[90, 100, 110, 120, 125, 130, 140, 135, 130, 120, 110, 100],
                         [70, 75, 80, 85, 95, 100, 105, 110, 115, 120, 125, 130]])

# Changer le style du graphique pour un style comique
plt.xkcd()

# Tracer le chiffre d'affaires mensuel pour chaque point de vente
plt.plot(months, revenue_data[0], marker='o', label=store_locations[0])
plt.plot(months, revenue_data[1], marker='o', label=store_locations[1])

# Mettre en évidence les promotions spéciales
plt.annotate("Pic du aux grosses soldes de Juillet.", xy=('Juil', 138), xytext=('Juin', 125),
             arrowprops=dict(arrowstyle='->', color='blue'))

# Ajouter un titre et des étiquettes
plt.title('Comparaison des revenus mensuels des magasins de detail (2023)')
plt.xlabel('Mois')
plt.ylabel("Chiffre d'affaires (en milliers)")
plt.grid(True)
plt.legend()
plt.show();
Comparaison Des Revenus Mensuels Des Magasins De Detail
  • Pour ajouter des étiquettes, nous devons parcourir les noms et utiliser la méthode annotate pour chaque point du nom. Dans ce cas, tu n’as pas besoin d’utiliser les paramètres xy et arrowprops. Mais tu dois utiliser textcoords='offset points', ce qui garantit que les positions spécifiées pour l’étiquette (dans ce cas, xytext) sont interprétées dans un système de coordonnées dont l’origine est (0, 0).
# Exemple de données pour le chiffre d'affaires d'un magasin de détail au cours d'un mois donné
store_names = ['Magasin A', 'Magasin B', 'Magasin C', 'Magasin D']
revenue_data = np.array([120, 150, 155, 130])  # Chiffre d'affaires en milliers
colors = ['red', 'green', 'blue', 'orange']

# Tracer le chiffre d'affaires des magasins en points
plt.scatter(store_names, revenue_data, s=150, c=colors, marker='o', label='Revenue')

# Étiqueter chaque magasin
for i, store in enumerate(store_names):
    plt.annotate(store, (store, revenue_data[i]), textcoords="offset points", xytext=(0, 10), ha='center')
    # ou plt.text(store, revenue_data[i]+1,store)

# Ajouter un titre et des étiquettes
plt.title("Chiffre d'affaires des magasins de détail (mois spécifique)")
plt.xlabel('Magasins')
plt.ylabel("Chiffre d'affaires (en milliers)")
plt.ylim(110,160)
plt.grid(True)
plt.savefig(path+'plot_with_labels.png')
plt.show()
Chiffre Affaires Des Magasins De Detail

Remplir la zone entre les tracés #

Il est parfois nécessaire de mettre en évidence les régions situées entre deux tracés linéaires, afin d’aider les spectateurs à comprendre où une courbe dépasse l’autre. Ceci peut être réalisé grâce à la méthode fill_between de Matplotlib. L’intensité de la couleur de remplissage peut être contrôlée par le paramètre alpha.

  • Pour remplir toute la région entre l’axe x et la ligne de tracé, tu peux utiliser la commande plt.fill_between(x,y)
  • Pour remplir l’intersection entre deux lignes de tracé, tu peux utiliser la commande plt.fill_between(x,y1,y2)
  • Pour remplir l’intersection entre deux lignes de tracé uniquement si elles satisfont à une condition spécifiée, tu peux utiliser la commande plt.fill_between(x,y1,y2,where=condition)
  • Pour remplir plus d’une région du graphique avec des conditions et des couleurs différentes.

Voici quelques exemples des cas ci-dessus.

# Exemple de données
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

# Tracer la courbe
plt.plot(x, y, label='Courbe sinusoïdale', color='blue')

# Remplir la zone entre la courbe et l'axe des x
plt.fill_between(x, 0, y, alpha=0.3, color='blue')

# Ajouter un titre et des étiquettes
plt.title("Remplissage entre l'axe X et la courbe")
plt.grid(True)
plt.legend()
plt.show()
Remplissage Entre Axe X Et La Courbe
# Exemple de données
x = np.linspace(0, 2 * np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Tracer les deux courbes - Tracés de lignes multiples
plt.plot(x, y1, label='Courbe sinusoïdale', color='blue')
plt.plot(x, y2, label='Courbe du cosinus', color='red')

# Remplir la zone entre les deux courbes
plt.fill_between(x, y1, y2, alpha=0.3, color='purple')

# Ajouter un titre et des étiquettes
plt.title('Remplissage entre deux lignes de tracé')
plt.grid(True)
plt.legend()
plt.show()
Remplissage Entre 2 Courbes
# Pour le même tracé ci-dessus
# Remplir la région entre les deux courbes où y1 > y2
plt.fill_between(x, y1, y2, where=(y1 > y2), alpha=0.3, color='green')

# Mettre en évidence les promotions spéciales
plt.annotate('Zone où les valeurs du sinus sont supérieures à celles du cosinus.', xy=(3, 0.25), xytext=(2, 0.80),
             arrowprops=dict(arrowstyle='->', color='blue'))

# Ajouter un titre et des étiquettes
plt.title('Remplissage entre deux lignes de tracé avec condition')
plt.grid(True)
plt.legend()
plt.show()
Remplissage Entre 2 Courbes Avec Condition
# Tracer les deux courbes
plt.plot(x, y1, label='Courbe sinusoïdale', color='blue')
plt.plot(x, y2, label='Courbe du cosinus', color='red')

# Remplir plusieurs régions avec des couleurs différentes
plt.fill_between(x, y1, y2, where=(y1 > y2), alpha=0.3, color='green')
plt.fill_between(x, y1, y2, where=(y1 <= y2), alpha=0.3, color='orange')

# Ajouter un titre et des étiquettes
plt.title('Remplissage entre deux courbes avec des couleurs différentes')
plt.grid(True)
plt.legend()
plt.show()
Remplissage Entre 2 Courbes Avec Des Couleurs Diff

Tracer des données de séries temporelles #

Nous savons tous que les données de séries temporelles sont très courantes dans de nombreux domaines tels que la finance, la climatologie, l’analyse commerciale, etc. De plus, les données sont très volumineuses dans ces cas, nous ne pouvons pas tirer le meilleur parti des données en faisant simplement quelques agrégations ! Matplotlib nous offre des moyens d’interpréter facilement les données de séries temporelles.

Imagine que tu souhaites représenter le trafic d’un site web sur un mois. Si tu fais un tracé linéaire, l’axe des x sera très maladroit avec toutes les dates et tu ne pourrais pas voir les dates correctement ! Quelque chose comme ci-dessous :

Trafic Mensuel Du Site Web Sur 1 An V1
  • matplotlib.dates est un sous-module de Matplotlib qui fournit des outils et est utile lorsque tu traites des données de séries temporelles, te permettant de formater et de personnaliser l’apparence des valeurs de date et d’heure sur l’axe des x.
  • DateFormatter : Cette classe vous permet de personnaliser le format des étiquettes de date et d’heure sur l’axe des abscisses. Tu peux spécifier la manière dont les dates sont affichées, y compris l’ordre de l’année, du mois, du jour et l’utilisation de séparateurs.
  • DayLocator, MonthLocator, YearLocator, etc. : ces classes permettent de localiser et d’espacer les dates sur l’axe des abscisses. Tu peux spécifier la fréquence des coches, par exemple quotidienne, mensuelle ou annuelle.
  • AutoDateLocator, AutoDateFormatter : Ces classes déterminent automatiquement l’emplacement et le format des tics de date en fonction de la plage de données. Cette fonction est utile pour créer des tracés avec des axes de date dynamiques.
  • Lorsque tu traces des données de séries temporelles, tu peux en fait utiliser plot_date, spécifiquement pour les données DateTime, et traiter l’axe x comme des dates, ce qui permet d’améliorer le formatage automatique des dates et l’emplacement des coches.
  • Nous utilisons également plt.gcf() et plt.gca() qui sont “Get Current Format” et “Get Current Axes”. Crée un format de date à l’aide des méthodes ci-dessus et passe-le à plt.gca().xaxis.set_major_formatter(d_format)

Voyons le même exemple, mais avec seulement trois lignes de personnalisation supplémentaires qui rendent le tracé de la série temporelle facilement interprétable !

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import numpy as np
np.random.seed(10)

# Générons un échantillon de données de séries temporelles pour un mois
date_rng = pd.date_range(start='2022-01-01', end='2022-02-01')

# Générer des valeurs de trafic aléatoires pour un mois
traffic_data = np.random.randint(500, 5000,len(date_rng))

# Créer un DataFrame
traffic_df = pd.DataFrame({'Mois': date_rng, 'Trafic (visiteurs)': traffic_data})

# Créons maintenant un graphique de série temporelle
plt.figure(figsize=(12,8),dpi=300)
plt.plot(traffic_df['Mois'], traffic_df['Trafic (visiteurs)'], label='Trafic sur le site web', color='purple')

# Pour afficher toutes les dates d'un mois
plt.xticks(traffic_df['Mois'])

# créer un format de date pour l'axe des x : Mois Jour, Année en utilisant la méthode DateFormatter
date_format = mdates.DateFormatter('%b %d, %Y')
# Personnaliser le formatage des dates en utilisant la méthode sej_major_formatter de matplotlib
plt.gca().xaxis.set_major_formatter(date_format) 
# Formatage automatique de l'axe des x
plt.gcf().autofmt_xdate()

# Ajout d'étiquettes et de titres :
plt.xlabel('Mois')
plt.ylabel('Trafic (visiteurs)')
plt.title('Trafic mensuel du site web sur un an')

# Ajout de lignes de grille et de légendes :
plt.grid(True)
plt.legend(['Trafic sur le site web'], loc='upper right')

# Afficher le graphe
plt.show()
Trafic Mensuel Du Site Web Sur 1 An V2
  • Ainsi, en utilisant les méthodes de matplotlib.dates, nous sommes en mesure de personnaliser l’axe des x de manière à rendre le graphique plus lisible.

Création de tracés 3D #

Lorsque tu as affaire à 3 variables ou dimensions ou plus, la visualisation des données complexes par un tracé en 3D peut permettre de mieux comprendre les données. Les cas d’utilisation les plus courants sont la visualisation de la modélisation du terrain, des caractéristiques géographiques, des images médicales en 3D, etc.

La création de tracés 3D avec Matplotlib implique l’utilisation de la boîte à outils mpl_toolkits.mplot3d, qui fournit des fonctions pour créer différents types de visualisations 3D. Tu dois importer Axes3D pour visualiser les tracés en 3D à l’aide de la commande suivante from mpl_toolkits.mplot3d import Axes3D.

Tout d’abord, nous devons créer un objet figure Matplotlib en utilisant fig=plt.figure(). Pour ajouter un sous-graphe 3D à la figure, nous devons utiliser la méthode add_subplot, axes=fig.add_subplt(111,projection='3d'). Dans ce cas, (1, 1, 1) signifie qu’il n’y a qu’une seule ligne et une seule colonne, et que le sous-graphe actuel se trouve en première (et unique) position.

Créons un graphique de surface en 3D, tu peux également créer un graphique linéaire en 3D, un graphique de dispersion en 3D, etc.

from mpl_toolkits.mplot3d import Axes3D

# Créer une grille de valeurs X et Y
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)

# Définir la fonction à tracer (exemple : une forme de selle)
Z = X**2 - Y**2

# Créer un tracé de surface en 3D
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

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

# Ajouter un titre
ax.set_title('Tracé de surface en 3D')
plt.show()
Trace De Surface En 3d

Incorporer des animations et de l’interactivité dans les graphiques #

Ce serait bien de pouvoir tourner, zoomer et survoler pour voir l’emplacement du tracé 3D ci-dessus, n’est-ce pas ? Devine quoi, nous pouvons le faire en une seule ligne ! Utilise la commande %matplotlib notebook dans voton Jupyter Notebook pour rendre le tracé interactif. Si tu souhaites revenir à un tracé statique, utilise la commande %matplotlib inline.

Lorsque les tracés interactifs sont activés, tu peux également créer de jolis tracés d’animation, comme une onde sinusoïdale en mouvement, etc. Cela peut être réalisé en utilisant les méthodes FuncAnimation du module matplotlib.animation. La méthode FncAnimation prend en compte l’objet figure, la fonction à appeler de manière répétée, l’intervalle de temps pour appeler la fonction. Le code ci-dessous crée une onde sinusoïdale animée. Ainsi, la fonction animate sera appelée toutes les secondes et le tracé résultant sera représenté dans l’objet figure, de sorte que nous obtenons un tracé d’animation en continu.

Dans la fonction animate, si tu peux ajouter pd.read_csv('live_data.csv') pour appeler un fichier csv qui est souvent mis à jour, alors tu as un tracé en temps réel qui est mis à jour au fur et à mesure que les données changent.

from matplotlib.animation import FuncAnimation
%matplotlib notebook

# Créer une figure et un axe
fig, ax = plt.subplots()

# Fonction de mise à jour de l'animation
def animate(frame):
    x = np.linspace(0, 2 * np.pi, 1000)
    y = np.sin(x + 0.1 * frame)  # Varier la phase pour créer une animation
    plt.cla()
    ax.plot(x, y, 'bo', markersize=10)

# Créer l'animation
ani = FuncAnimation(fig, animate,interval=1000)

plt.title('Point animé sur onde sinusoïdale')
plt.show()

Conclusion #

Dans ce guide complet Matplotlib, nous avons compris les principes fondamentaux des tracés, les personnalisations, les sous-graphes multiples, le remplissage entre les courbes, et les fonctionnalités avancées telles que les tracés en 3D, le tracé des données de séries temporelles, et l’ajout d’annotations et de texte.

Alors que tu poursuis ton voyage dans le monde de la Data Science et de l’analyse de données, rappelle-toi que Matplotlib fournit les bases pour créer des visuels convaincants qui racontent l’histoire de tes données, alors n’hésite pas à jouer avec. J’espère que ce guide t’a été utile.

T'en as pensé quoi ?