Tutoriel d'animation Matplotlib - Créez des visualisations époustouflantes

Name: Rajiv Chandra

Published on 17/08/2023

La visualisation des données est un outil puissant entre les mains de ceux qui savent l'utiliser. Elle peut transformer des ensembles de données complexes en informations compréhensibles, et grâce à l'utilisation d'animations, ces informations peuvent être rendues encore plus captivantes. C'est là que Matplotlib, une bibliothèque polyvalente en Python, entre en jeu. Matplotlib nous permet de créer des visualisations statiques, animées et interactives en Python, ce qui en fait un outil essentiel pour tout(e) scientifique des données ou analyste.

Dans ce tutoriel, nous nous concentrerons sur les capacités d'animation de Matplotlib. Nous explorerons comment créer des animations, les différents types de tracés que vous pouvez animer et les différents formats dans lesquels vous pouvez enregistrer vos animations. Nous aborderons également certains problèmes courants auxquels les utilisateurs sont confrontés, tels que les animations qui ne fonctionnent pas dans les notebooks Jupyter, et nous proposerons des solutions à ces problèmes. Ainsi, que vous soyez un(e) scientifique des données chevronné(e) ou un(e) débutant(e) qui débute tout juste, ce tutoriel a quelque chose pour vous.

Vous souhaitez créer rapidement une visualisation des données à partir d'un dataframe Python Pandas sans code ?

PyGWalker est une bibliothèque Python pour l'analyse exploratoire des données avec visualisation. PyGWalker (opens in a new tab) peut simplifier votre flux de travail d'analyse et de visualisation des données dans un notebook Jupyter, en transformant votre dataframe pandas (et le dataframe polars) en une interface utilisateur de style Tableau pour l'exploration visuelle.

(opens in a new tab)

Qu'est-ce que l'animation Matplotlib ?

L'animation Matplotlib est une fonctionnalité de la bibliothèque Matplotlib qui permet de créer des visualisations dynamiques. Contrairement aux tracés statiques, les animations peuvent montrer des changements dans le temps, ce qui en fait un excellent outil pour représenter des données chronologiques. Par exemple, les cours des actions au fil des années, le changement climatique au cours de la dernière décennie, ou tout phénomène qui évolue dans le temps peut être efficacement démontré à l'aide d'animations.

Le module d'animation de Matplotlib est composé de plusieurs classes qui fournissent une infrastructure pour la création d'animations. La plus importante d'entre elles est la classe FuncAnimation, qui est utilisée pour créer des animations en appelant une fonction de manière répétée (d'où le nom "FuncAnimation"). Cette classe permet de créer facilement des animations où l'état (ou les données) du tracé est mis à jour dans chaque image.

Création d'une animation avec Matplotlib

La création d'une animation avec Matplotlib implique quelques étapes. Tout d'abord, vous devez configurer la figure et l'axe du tracé. Ensuite, vous définissez la fonction d'animation, qui met à jour les données dans chaque image. Enfin, vous créez une instance de la classe FuncAnimation, en passant la figure, la fonction d'animation et le nombre d'images en tant qu'arguments.

Voici un exemple simple de création d'une animation de tracé de lignes :

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
# Configuration de la figure et de l'axe
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-')
 
def init():
    ax.set_xlim(0, 2*np.pi)
    ax.set_ylim(-1, 1)
    return ln,
 
def update(frame):
    xdata.append(frame)
    ydata.append(np.sin(frame))
    ln.set_data(xdata, ydata)
    return ln,
 
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
                    init_func=init, blit=True)
plt.show()

Dans cet exemple, la fonction init configure les limites du tracé et renvoie l'objet de ligne (ln). La fonction update est appelée pour chaque image, où elle ajoute les nouvelles données (le sinus du numéro de l'image) à ydata et met à jour les données de l'objet de ligne. La classe FuncAnimation est ensuite utilisée pour créer l'animation.

Types de tracés que vous pouvez animer avec Matplotlib

Matplotlib est très polyvalent et vous permet d'animer une grande variété de tracés. Voici quelques exemples :

Tracés de lignes : Comme nous l'avons vu dans la section précédente, des tracés de lignes peuvent être animés pour montrer l'évolution d'une ou plusieurs quantités dans le temps. Cela est particulièrement utile pour les données chronologiques.
Tracés de dispersion : Les tracés de dispersion peuvent être animés pour montrer le mouvement de points dans un espace en 2D. Cela peut être utilisé pour visualiser le regroupement ou la classification des points de données dans le temps.
Tracés de barres : Les tracés de barres peuvent être animés pour montrer l'évolution de la quantité représentée par la hauteur des barres. Cela peut être utilisé pour visualiser les changements dans un ensemble de données dans le temps.
Histogrammes : Les histogrammes peuvent être animés pour montrer l'évolution de la distribution d'un ensemble de données dans le temps.
Tracés en 3D : Matplotlib prend également en charge le tracé en 3D. Vous pouvez animer des tracés en 3D pour montrer les changements dans un ensemble de données en 3D. Cela peut être utile pour visualiser des données scientifiques en 3D.
Sous-tracés : Vous pouvez animer plusieurs sous-tracés simultanément. Cela peut être utilisé pour comparer différents ensembles de données ou différentes vues du même ensemble de données.

N'oubliez pas que le type de tracé que vous choisissez d'animer doit dépendre de la nature de vos données et de ce que vous souhaitez transmettre avec votre visualisation.

Enregistrer votre animation Matplotlib

Une fois que vous avez créé votre animation, vous voudrez peut-être l'enregistrer pour une utilisation ultérieure ou pour la partager avec d'autres personnes. Matplotlib fournit la méthode Animation.save à cette fin. Cette méthode vous permet d'enregistrer l'animation dans différents formats, notamment MP4, AVI et vidéo HTML5.

Voici un exemple de sauvegarde d'une animation :

ani.save('animation.mp4', writer='ffmpeg', fps=30)

Dans cet exemple, l'animation est enregistrée sous forme de fichier MP4 en utilisant le writer FFmpeg. Le paramètre fps spécifie le nombre d'images par seconde dans l'animation enregistrée.

Il est important de noter que l'enregistrement des animations nécessite l'installation d'un writer approprié sur votre système. Pour la plupart des formats courants, Matplotlib utilisera automatiquement le writer approprié. Cependant, pour certains formats, vous devrez peut-être installer un logiciel supplémentaire. Par exemple, l'enregistrement des animations en tant que fichiers MP4 nécessite l'installation de FFmpeg sur votre système.

Dans la prochaine partie de ce tutoriel, nous approfondirons les différents types de tracés que vous pouvez animer avec Matplotlib et fournirons des exemples pour chacun. Nous discuterons également de la façon d'animer des tracés 3D, de créer une animation de barre de progression et d'ajouter des animations de texte à vos tracés. Restez à l'écoute !

Animation de tracés 3D avec Matplotlib

Les capacités 3D de Matplotlib peuvent être utilisées pour créer des animations fascinantes qui ajoutent une dimension supplémentaire à vos visualisations de données. Le processus est similaire à la création d'animations 2D, mais au lieu de créer un tracé 2D, vous créez un tracé 3D en utilisant la classe Axes3D.

Voici un exemple de création d'une animation de surface 3D :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from mpl_toolkits.mplot3d import Axes3D
 
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
 
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z = np.sin(np.sqrt(x**2 + y**2))
 
def update(num):
    ax.view_init(elev=10., azim=num)
    return ln,
 
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 100), blit=True)
plt.show()

Dans cet exemple, la fonction update modifie l'angle de visualisation du tracé pour chaque frame, créant ainsi un effet de rotation.

Création d'une animation de barre de progression avec Matplotlib

Les barres de progression sont un excellent moyen de visualiser l'avancement d'un calcul ou d'un processus. Avec Matplotlib, vous pouvez créer une barre de progression animée qui se met à jour en temps réel. Voici un exemple simple :

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
bar = plt.bar([0], [0], color='b')
 
def update(i):
    bar[0].set_height(i / 100.)
    return bar
 
ani = FuncAnimation(fig, update, frames=range(101), repeat=False)
plt.show()

Dans cet exemple, la hauteur de la barre est mise à jour à chaque frame, créant ainsi l'effet d'une barre de progression qui se remplit.

Ajout d'animations de texte aux tracés Matplotlib

L'ajout de texte animé à vos tracés peut les rendre plus informatifs et captivants. Vous pouvez animer le texte dans vos tracés Matplotlib en utilisant la classe Text et la classe FuncAnimation. Voici un exemple :

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
 
def update(i):
    text.set_text(f'Image {i}')
    return text,
 
ani = FuncAnimation(fig, update, frames=range(10), blit=True)
plt.show()

Dans cet exemple, le texte affiché sur le tracé est mis à jour à chaque frame, créant une animation de texte simple.

Animation de plusieurs sous-tracés avec Matplotlib

Matplotlib permet la création de plusieurs sous-tracés dans une seule figure, et ces sous-tracés peuvent être animés individuellement. Cela est particulièrement utile lorsque vous souhaitez comparer différents ensembles de données ou différentes vues du même ensemble de données côte à côte. Voici un exemple de création d'animations de plusieurs sous-tracés :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, axs = plt.subplots(2)
 
x = np.linspace(0, 2*np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)
 
line1, = axs[0].plot(x, y1, color='blue')
line2, = axs[1].plot(x, y2, color='red')
 
def update(frame):
    line1.set_ydata(np.sin(x + frame / 100))
    line2.set_ydata(np.cos(x + frame / 100))
    return line1, line2
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Dans cet exemple, nous avons deux sous-tracés : l'un montrant une onde sinusoïdale et l'autre montrant une onde cosinusoïdale. La fonction update modifie la phase des ondes, créant une animation de deux ondes se déplaçant de manière synchronisée.

Création d'animations avec des palettes de couleurs changeantes

Modifier la palette de couleurs de votre animation peut ajouter une couche d'informations supplémentaire à votre visualisation. Par exemple, vous pouvez utiliser la couleur pour représenter une troisième dimension dans un tracé 2D ou pour mettre en évidence des points de données spécifiques. Voici un exemple de création d'une animation avec une palette de couleurs changeante :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.cm import get_cmap
 
fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
scat = ax.scatter(x, y, c=y, cmap=get_cmap('viridis'))
 
def update(frame):
    y = np.sin(x + frame / 100)
    scat.set_offsets(np.c_[x, y])
    scat.set_array(y)
    return scat,
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Dans cet exemple, nous utilisons la fonction scatter pour créer un nuage de points d'une onde sinusoïdale, où la couleur de chaque point est déterminée par sa valeur y. La fonction update modifie la phase de l'onde et met à jour les couleurs des points, créant ainsi une animation d'une onde mobile avec une palette de couleurs changeante.

Animation de données en temps réel avec Matplotlib

Les animations Matplotlib peuvent également être utilisées pour visualiser des données en temps réel. Cela peut être utile dans différentes applications, telles que la surveillance des données de capteurs, le suivi des prix des actions ou la visualisation d'algorithmes d'apprentissage automatique. Voici un exemple de visualisation de données en temps réel :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
line, = ax.plot([])
 
def update(frame):
    line.set_data(range(frame), np.random.rand(frame))
    ax.relim()
    ax.autoscale_view()
    return line,
 
ani = FuncAnimation(fig, update, frames=range(1, 101), blit=True)
plt.show()

Dans cet exemple, la fonction update génère un nouveau point de données aléatoire pour chaque image, simulant des données en temps réel. Les limites du graphique sont mises à jour à chaque image pour accueillir les nouvelles données.

Utiliser Matplotlib pour animer des simulations scientifiques

Les capacités d'animation de Matplotlib peuvent être utilisées pour visualiser des simulations scientifiques.

Par exemple, vous pouvez animer le mouvement de particules dans une simulation de physique, la croissance d'une population dans une simulation de biologie, ou la propagation d'une maladie dans une simulation d'épidémiologie. Voici un exemple d'animation d'une simple simulation physique d'une balle rebondissante :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ball = plt.Circle((5, 5), 0.5, color='blue')
ax.add_patch(ball)
 
vx, vy = 0.1, 0.2  # Vitesse
 
def update(frame):
    x, y = ball.center
    x += vx
    y += vy
    if x > 10 or x < 0:  # Rebondir en cas de collision avec le bord
        vx *= -1
    if y > 10 or y < 0:
        vy *= -1
    ball.center = (x, y)
    return ball,
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Dans cet exemple, la fonction update met à jour la position de la balle en fonction de sa vitesse, et inverse la vitesse si la balle entre en collision avec le bord du graphique, créant ainsi une animation d'une balle rebondissante.

Questions fréquentes

Qu'est-ce que l'animation Matplotlib ?
L'animation Matplotlib est une fonctionnalité de la bibliothèque Matplotlib en Python qui permet la création de visualisations dynamiques. Contrairement aux graphiques statiques, les animations peuvent montrer des changements dans le temps, ce qui en fait un excellent outil pour représenter des données chronologiques.
Comment créer une animation avec Matplotlib ?
Pour créer une animation avec Matplotlib, il faut configurer la figure et l'axe du graphique, définir la fonction d'animation qui met à jour les données à chaque image, et créer une instance de la classe FuncAnimation, en passant la figure, la fonction d'animation et le nombre d'images en tant qu'arguments.
Quels types de graphiques puis-je animer avec Matplotlib ?
Matplotlib vous permet d'animer une grande variété de graphiques, y compris des graphiques linéaires, des graphiques de dispersion, des graphiques à barres, des histogrammes, des graphiques en 3D et des sous-graphiques.

Troubleshooting: Matplotlib.pyplot Not Resolved From Source Unlocking the Power of Matplotlib Stylesheets for Enhanced Data Visualization