Tuto Python : Comment faire des animations ?
Rédigé par Mouna HAMIM, Publié le 29 Décembre 2020, Mise à jour le Jeudi, 31 Décembre 2020 01:17
Table des matières
7.1. Comment utiliser cette librairie ?
Introduction
Python est un langage informatique très populaire dans le monde de la programmation. Grâce à sa variété et les différents services et possibilités qu’il offre, il est le langage préféré de plusieurs programmeurs. Aujourd’hui, nous allons découvrir une de ses fonctionnalités principales qui est la création d’animation.
En effet, Python a plusieurs bibliothèques et modules qui permettent de créer des animations telles que des figures dynamiques ou des tableaux interactifs. Dans ce tutoriel, nous allons découvrir les différents modules d’animations en Python ainsi que des exemples afin de concrétiser les notions.
1. Plotly express
Plotly express est un sous module built-in de plotly qui contient des fonctions qui permettent de créer plusieurs figures à la fois. Cette API offre plus de 30 fonctions de création de différentes figures. En effet, chaque figure créée par une seule fonction du module plotly express peut être créée avec l’appel des objets graphes seuls mais avec 10 à 100 fois plus de code !
2. Fonctions basiques de Plotly express
2.1. Scatter
Scatter est une fonction très basique de plotly express ou px, elle permet de retourner une figure animée qui contient les points des données représentés ainsi que leur cordonnées dès qu’on met le curseur sur un point.
Exemple
Syntaxe
# x et y sont donnés comme tableau
import plotly.express as px
fig = px.scatter(x=[0, 1, 5, 3, 4], y=[0, 1, 4, 3, 6])
fig.show()
Résultat de l’exécution
Comme vous pouvez le constater, le résultat est une représentation graphique des points donnés une fois que vous passez le curseur sur un point, ses cordonnées s’afficheront. Par exemple, si vous passez le curseur sur le premier point, il affichera X=0, Y=0.
2.2. Line
Chaque point de données est représenté par un sommet (dont l’emplacement est indiqué par les colonnes x et y) d’un point de polyligne dans l’espace 2D.
Exemple
Dans cet exemple, on veut créer une courbe animée qui décrit l’espérance de vie au Maroc selon les années.
Syntaxe
import plotly.express as px
df = px.data.gapminder().query (" country== 'France' ")
fig = px.line(df , x="year", y=" lifeExp ", title='Life expectancy in Canada')
fig.show ()
Résultat de l’exécution
2.3. Timeline
La fonction px.timeline permet de dessiner des graphes chronologiques qui décrivent l’évolution d’une variable en fonction du temps.
Exemple
Syntaxe
import pandas as pd
import plotly.express as px
df = pd.DataFrame([
dict (Task= "Job A", Start= '2009-01-01', Finish= '2009-02-28'),
dict (Task= "Job B", Start= '2009-03-05', Finish= '2009-04-15'),
dict (Task= "Job C", Start= '2009-02-20', Finish= '2009-05-30')
])
fig = px.timeline (df, x_start= "Start", x_end= "Finish", y= "Task")
fig.update_yaxes (autorange= "reversed") # otherwise tasks are listed from the bottom up
fig.show()
Résultat de l’exécution
Le résultat de l’exécution retourne une représentation chronologique des événements. Par exemple, si vous cliquez sur le premier rectangle, l’intitulé de la tâche, la date de son début et sa fin s’afficheront et ainsi de suite pour les autres éléments.
2.4. bar
Cette fonction permet de représenter les données avec des rectangles.
Exemple
Dans cet exemple, on veut faire une animation de l’évolution de la population du Maroc en fonction des années.
Syntaxe
import plotly.express as px
data_canada = px.data.gapminder().query("country == 'Morocco'")
fig = px.bar(data_canada, x='year', y='pop',title='')
fig.show()
Résultat de l’exécution
A présent, nous allons passer à d’autre types d’animations du module px .
3. Fonctions Part-of-Whole
3.1. Pie charts
Un graphique circulaire est un graphique statistique circulaire, qui est divisé en secteurs dans le but d’illustrer des proportions numériques.
Exemple
Dans ce premier exemple, nous allons afficher un pie chart qui permet de visualiser les proportions de trois classes différentes.
Syntaxe
import plotly.graph_objects as go
etiquettes = ['Classe 1' , ' Classe 2' , 'Classe 3', ' Classe 4 ' ]
valeurs = [4500, 2500, 1053, 500]
figure = go.Figure (data= [go.Pie (labels=etiquettes, values=valeurs)])
figure.show ()
Résultat de l’exécution
Exemple
Dans cet exemple, on veut afficher la distribution de la population du continent africain selon les pays.
Syntaxe
import plotly.express as px
data = px.data.gapminder().query("year == 2007").query(" continent == ' Africa '")
data.loc [data['pop'] < 2.e6, 'country'] = 'Other countries' # Represent only large countries
fig = px.pie (data, values='pop', names='country', title='Population of African continent')
fig.show ()
Résultat de l’exécution
3.2. Tree Map
Px.treemap est une fonction qui permet de visualiser les données hiérarchiquement grâce à des formes imbriquées. Cette hiérarchie est définie par des étiquettes (nom des éléments) ainsi que des attributs parents .
Exemple
Dans cet exemple, nous allons créer un graphique de type treemap qui permet de modéliser les pays du monde entier dans un arbre. Par exemple, dans notre arbre, le premier nœud sera Monde et il n’aura aucun parent. Ce nœud parent aura plusieurs enfants continent (‘Africa’ , ‘Europe’ , ‘USA’…) qui eux-mêmes auront d’autre nœuds enfant pour représenter les pays.
Syntaxe
import plotly.express as px
import numpy as np
data = px.data.gapminder().query(" year == 2007 ")
data["world"] = " monde "
fig = px.treemap (data, path=['world', 'continent', 'country'], values='pop',
color='lifeExp', hover_data=[' iso_alpha '] ,
color_continuous_scale = ' RdBu ',
color_continuous_midpoint = np.average (data ['lifeExp'] , weights=data ['pop'] ) )
fig.show( )
Résultat de l’exécution
Si vous cliquez sur monde, une étiquette affichera le nombre d’habitants total de la planète. Vous remarquerez que Parent est vide pour monde. Ceci est normal car c’est le nœud principal qui n’a aucun parent. Ensuite, si vous cliquez sur China par exemple, une étiquette sera affichée contenant le nombre d’habitants, le code iso_alpha du pays ainsi que le parent du pays qui sera Asia dans ce cas.
3.3. Sunburst
Avec px.sunburst, chaque ligne de la DataFrame est représentée comme un secteur de la sunburst . Cet outil est très similaire à treemap mais avec une représentation graphique assez différente.
Exemple
Syntaxe
import plotly.express as px
data = dict (
caracteres = [" Eva ", " Chain " , " Sethe " , " Menos " , "Naomi" , "Abdel" , " Rawan " , " Epoch " , " Azur " ] ,
parents= [" ", "Eva" , "Eva" , " Sethe " , " Sethe " , "Eva", "Eva", "Rawan" , "Eva" ] ,
valeurs= [14 , 10 , 10 , 12 , 6 , 2 , 6 , 6 , 4 ] )
fig = px.sunburst (
data,
names = ' caracteres ',
parents=' parents ',
values= 'valeurs',
)
fig.show ()
Résultat de l’exécution
4. Distributions 1-D
4.1. Histogram
Cet outil permet de représenter la distribution des données en faisant le compte de chaque variable à compter par rapport au compte total .
Exemple
Dans cet exemple, nous désirons visualiser la distribution de quelques données de la base de données iris.
Syntaxe
import plotly.express as px
df = px.data.iris()
fig = px.histogram (df, x= " species " )
fig.show ()
Résultat de l’exécution
4.2. Box
Box est l’outil qui permet de créer des boites à moustache afin de visualiser une représentation statique des données numériques à travers leurs quartiles.
Exemple
Syntaxe
import plotly.express as pex
data = pex.data.iris ()
fig = pex.box (data, x=" sepal_width ", y= " species")
fig.show ()
Résultat de l’exécution
Exemple
Syntaxe
import plotly.express as pex
data = pex.data.iris ()
fig = pex.box (data, x="sepal_width", y="species")
fig.show ()
Résultat de l’exécution
5. Distributions 2-D
5.1. Density_Heatmap
Un histogramme 2D ou ce qu’on appelle généralement density_heatmap est une présentation 2D de l’histogramme basique. Pour faire cela, nous allons faire appel à la fonction px.density_map .
Exemple
Syntaxe
import plotly.express as px
df = px.data.iris()
fig = px.density_heatmap(df, x=" species ", y= " petal_length " )
fig.show()
Résultat de l’exécution
6. 3-D Dimensions
6.1. Scatter_3d
Cet outil permet de visualiser les données dans un espace 3d.
Exemple
Dans cet exemple, nous voulons visualiser les données de la base px.data.tips() . Les paramètres auxquels nous nous intéressons sont : le total_bill , sex et tip .
Syntaxe
import plotly.express as px
df = px.data.tips()
fig = px.scatter_3d(df, x='total_bill', y='sex', z='tip',
color='day')
fig.show()
Résultat de l’exécution
7. Module Animation
Nous allons à présent passer à un autre module de Python qui permet de faire des animations aussi. Animation est un sous-module du matplotlib qui permet de créer des figures d’animations .
7.1. Comment utiliser cette librairie ?
Il faut savoir que la base des animations dans cette librairie sont les deux lignes suivantes. Si vous les comprenez bien, croyez nous le tour est joué !
Syntaxe
import matplotlib.animation as anim
animation = anim.FuncAnimation(fig, chartfunc, interval = 100)
Maintenant, jetons un coup d’œil sur les paramètres de cette fonction :
- ·Fig : C’est l’objet figure que nous allons utiliser pour dessiner nos animations.
- ·Chartfunc : fonction qui prend en entrée un caractère numérique correspondant au temps .
- ·Interval : représente le délai entre les frames, il prend la valeur 200 millisecondes par défaut.
Nous allons à présent faire des exemples afin que vous comprenez d’avantage comment on utilise le module animation.
Exemple
Dans l’exemple suivant, on veut créer une animation d’une forme de sinus avec une petite balle rouge qui traverse toute la courbe. Vous devez tout d’abord installer cette fonctionnalité qui va nous permettre d’enregistrer notre animation comme une figure .mp4 :
Commande sur anaconda prompt :
pip install ffmpeg-python
Commande sur terminal jupyter notebook:
! pip install ffmpeg-python
Syntaxe :
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
deux_pi = 2*np.pi
fig, ax = plt.subplots()
temps = np.arange(0.0, deux_pi, 0.001)
surf = np.sin(temps)
le = plt.plot(temps, surf)
ax = plt.axis([0,deux_pi,-1,1])
PointRouge = plt.plot([0], [np.sin(0)], 'ro')
def animate(i):
redDot.set_data(i, np.sin(i))
return PointRouge
# create animation using the animate() function
myAnimation = animation.FuncAnimation(fig, animate, frames=np.arange(0.0, deux_pi, 0.1), \
interval=10, blit=True, repeat=True)
myAnimation.save('sinus.gif', fps=30, extra_args=['-vcodec', 'libx264'])
- On commence tout d’abord par importer les modules nécessaires au fonctionnement de notre code comme les modules numpy, matplotlib et matplotlib.pyplot.
- Ensuite, nous définissons une figure nommée fig avec sa plage et ses axes. Puis, nous créons une instance de l’objet vide que nous allons modifier par à la suite dans l’animation. La fonction d’initialisation initialise les données et définit également les limites de l’axe.
- La fonction qui suit est créée selon notre besoin. Dans notre cas, une onde sinusoïdale qui de déplace en fonction de la variable i . Elle renvoie un tuple qui montre au cadre d’animation les parties devant être animées.
- Finalement, nous créons l’objet animation, on modifie ces paramètres puis on enregistre la figure sous format .mp4 .
Résultat de l’exécution :
Exemple :
Voici un autre exemple d’animation qui utilise FuncAnimation du module matplotlib.animation. Ici, nous voulons créer une animation de la fonction sinus ().
Syntaxe :
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
plt.style.use('seaborn-pastel')
figure = plt.figure ()
axs = plt.axes (xlim = (0, 4), ylim= (-2, 2))
line, = axs.plot ([], [], lw = 3)
def initialization ():
line.set_data ([], [])
return line,
def animation(j):
x_a = np.linspace(0, 4, 1000)
y_a = np.sin(2 * np.pi * (x_a - 0.01 * j))
line.set_data(x_a , y_a)
return line,
anima= FuncAnimation (figure, animation, init_func=initialisation,
frames=200, interval=20 , blit=True )
anima.save('sinus_wav.gif', writer='imagemagick')
- Nous commençons par créer une simple fenêtre de figure avec un axe. Puis, nous instancions notre objet vide que nous allons modifier par la suite dans l’animation.
- la fonction initialisation () est celle qui va entamer l’animation, elle initialise les données et définit aussi les limites des axes dans la figure.
- Finalement, nous définissons la fonction animation () qui a comme paramètre le numéro d’image j . Le but est de créer une onde sinusoïdale avec un décalage correspondant à la valeur de i. Elle retourne un tuple d’objets de type plot qui doit être animé par l’objet d’animation final où le paramètre blit est mis à True.
Résultat de l’exécution :
Conclusion
Nous sommes arrivés à la fin de ce tutoriel, maintenant vous savez comment créer des animations en Python grâce aux modules Plotly.Express et Animation de matplotlib. Dorénavant, il vous sera plus facile de créer des figures animées afin de comprendre des phénomènes par exemple ou bien pour la visualisation de vos données.
Nous vous conseillons donc d’utiliser ces outils très souvent dans vos visualisons afin qu’ils deviennent familiers pour vous. Nous verrons dans des prochains tutoriels d’autres outils d’animation plus avancés. Bon courage et à très bientôt chers programmeurs !