TRAÇAGE DE GRAPHIQUES EN PYTHON | ENSEMBLE 3

Traçage de graphiques en Python | Ensemble 1 Traçage de graphiques en Python | Ensemble 2 Matplotlib est une bibliothèque assez complète qui prend en charge Animations des graphiques également. Les outils d'animation se concentrent sur le matplotlib.animation classe de base qui fournit un cadre autour duquel la fonctionnalité d'animation est construite. Les principales interfaces sont Animation chronométrée et FonctionAnimation et sur les deux FonctionAnimation est le plus pratique à utiliser. Installation:

pip install numpy

ici

Mise en œuvre: Python

# importing required modules import matplotlib.pyplot as plt import matplotlib.animation as animation import numpy as np # create a figure axis and plot element fig = plt.figure() ax = plt.axes(xlim=(-50 50) ylim=(-50 50)) line = ax.plot([] [] lw=2) # initialization function def init(): # creating an empty plot/frame line.set_data([] []) return line # lists to store x and y axis points xdata ydata = [] [] # animation function def animate(i): # t is a parameter t = 0.1*i # x y values to be plotted x = t*np.sin(t) y = t*np.cos(t) # appending new points to x y axes points list xdata.append(x) ydata.append(y) # set/update the x and y axes data line.set_data(xdata ydata) # return line object return line # setting a title for the plot plt.title('A growing coil!') # hiding the axis details plt.axis('off') # call the animator  anim = animation.FuncAnimation(fig animate init_func=init frames=500 interval=20 blit=True) # save the animation as mp4 video file anim.save('animated_coil.mp4' writer = 'ffmpeg' fps = 30) # show the plot plt.show()

Here is how the output animation looks like: Now let us try to understand the code in pieces:

```
fig = plt.figure() ax = plt.axes(xlim=(-50 50) ylim=(-50 50)) line = ax.plot([] [] lw=2)
```
Here we first create a figure i.e a top level container for all our subplots. Then we create an axes element hache qui fait office de sous-intrigue. La plage/limite pour les axes x et y est également définie lors de la création de l'élément axes. Enfin, nous créons le parcelle élément nommé comme doubler . Initialement, les points des axes x et y ont été définis comme des listes vides et des largeurs de ligne (lw) a été fixé à 2.
```
def init(): line.set_data([] []) return line
```
Now we declare a initialization function chaleur . Cette fonction est appelée par l'animateur pour créer la première image.
```
def animate(i): # t is a parameter t = 0.1*i # x y values to be plotted x = t*np.sin(t) y = t*np.cos(t) # appending new points to x y axes points list xdata.append(x) ydata.append(y) # set/update the x and y axes data line.set_data(xdata ydata) # return line object return line
```
This is the most important function of above program. animer() La fonction est appelée encore et encore par l'animateur pour créer chaque image. Le nombre de fois que cette fonction sera appelée est déterminé par le nombre de trames transmises comme cadres argument à l’animateur. animer() function takes the index of ith frame as argument.
```
t = 0.1*i
```
Here we cleverly use the index of current frame as a parameter!
```
x = t*np.sin(t) y = t*np.cos(t)
```
Now since we have the parameter t we can easily plot any parametric equation. For example here we are plotting a spiral using its parametric equation.
```
line.set_data(xdata ydata) return line
```
Finally we use set_data() fonction pour définir les données x et y, puis renvoyer l'objet de tracé doubler .
```
anim = animation.FuncAnimation(fig animate init_func=init frames=500 interval=20 blit=True)
```
Now we create the FuncAnimation object six . Il faut divers arguments expliqués ci-dessous : figue : chiffre à tracer. animer : la fonction à appeler de manière répétée pour chaque image . init_func : fonction utilisée pour dessiner un cadre clair. Il est appelé une fois avant la première image. cadres : nombre d'images. (Note: cadres peut également être un itérable ou un générateur.) intervalle : durée entre les images (en millisecondes) rester : le paramètre blit=True signifie que seules les parties qui ont changé seront dessinées.
```
anim.save('animated_coil.mp4' writer = 'ffmpeg' fps = 30)
```
Now we save the animator object as a video file using sauvegarder() fonction. Vous aurez besoin d'un scénariste pour enregistrer la vidéo d'animation. Dans cet exemple, nous avons utilisé le rédacteur de films FFMPEG. Donc écrivain est défini comme 'ffmpeg'. fps signifie image par seconde.

Exemple 2 This example shows how one can make a rotating curve by applying some simple mathematics! Python

# importing required modules import matplotlib.pyplot as plt import matplotlib.animation as animation import numpy as np # create a figure axis and plot element fig = plt.figure() ax = plt.axes(xlim=(-25 25) ylim=(-25 25)) line = ax.plot([] [] lw=2) # initialization function def init(): # creating an empty plot/frame line.set_data([] []) return line # set of points for a star (could be any curve) p = np.arange(0 4*np.pi 0.1) x = 12*np.cos(p) + 8*np.cos(1.5*p) y = 12*np.sin(p) - 8*np.sin(1.5*p) # animation function def animate(i): # t is a parameter t = 0.1*i # x y values to be plotted X = x*np.cos(t) - y*np.sin(t) Y = y*np.cos(t) + x*np.sin(t) # set/update the x and y axes data line.set_data(X Y) # return line object return line # setting a title for the plot plt.title('A rotating star!') # hiding the axis details plt.axis('off') # call the animator  anim = animation.FuncAnimation(fig animate init_func=init frames=100 interval=100 blit=True) # save the animation as mp4 video file anim.save('basic_animation.mp4' writer = 'ffmpeg' fps = 10) # show the plot plt.show()

Here is how the output of above program looks like: Here we have used some simple mathematics to rotate a given curve.

La forme en étoile est obtenue en mettant k = 2,5 et 0p = np.arange(0 4*np.pi 0.1) x = 12*np.cos(p) + 8*np.cos(1.5*p) y = 12*np.sin(p) - 8*np.sin(1.5*p)
Now in each frame we rotate the star curve using concept of rotation in complex numbers. Let x y be two ordinates. Then after rotation by angle theta the new ordinates are: {x}' = xcos theta - ysin theta {y}' = xsin theta + ycos theta The same has been applied here:
```
X = x*np.cos(t) - y*np.sin(t) Y = y*np.cos(t) + x*np.sin(t)
```

Dans l’ensemble, les animations sont un excellent outil pour créer des choses étonnantes et bien d’autres choses peuvent être créées en les utilisant. C'est ainsi que des tracés animés peuvent être générés et enregistrés à l'aide de Matplotlib. Créer un quiz

TechCodeview

Traçage de graphiques en Python | Ensemble 3