TRACCIARE GRAFICI IN PYTHON | INSIEME 3

Tracciare grafici in Python | Insieme 1 Tracciare grafici in Python | Insieme 2 Matplotlib è una libreria piuttosto estesa che supporta Animazioni anche dei grafici. Gli strumenti di animazione sono incentrati su matplotlib.animation classe base che fornisce un framework attorno al quale è costruita la funzionalità di animazione. Le principali interfacce sono Animazione temporizzata E FuncAnimation e fuori dai due FuncAnimation è quello più comodo da usare. Installazione:

pip install numpy

Qui

Attuazione: 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 ascia che funge da sottotrama. L'intervallo/limite per gli assi xey viene definito anche durante la creazione dell'elemento assi. Infine creiamo il complotto elemento denominato come linea . Inizialmente i punti degli assi xey sono stati definiti come elenchi vuoti e larghezza di linea (lw) è stato impostato come 2.
```
def init(): line.set_data([] []) return line
```
Now we declare a initialization function Calore . Questa funzione viene chiamata dall'animatore per creare il primo fotogramma.
```
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. animare() La funzione viene chiamata più e più volte dall'animatore per creare ciascun fotogramma. Il numero di volte in cui questa funzione verrà chiamata è determinato dal numero di frame passati cornici discussione con l'animatore. animare() 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() funzione per impostare i dati xey e quindi restituire l'oggetto della trama linea .
```
anim = animation.FuncAnimation(fig animate init_func=init frames=500 interval=20 blit=True)
```
Now we create the FuncAnimation object sei . Ci vogliono vari argomenti spiegati di seguito: Fico : figura da tracciare. animare : la funzione da richiamare ripetutamente per ogni frame . init_funz : funzione utilizzata per disegnare una cornice chiara. Viene chiamato una volta prima del primo fotogramma. cornici : numero di fotogrammi. (Nota: cornici può anche essere un iterabile o un generatore.) intervallo : durata tra i fotogrammi (in millisecondi) rimanere : impostando blit=True significa che verranno disegnate solo le parti che sono cambiate.
```
anim.save('animated_coil.mp4' writer = 'ffmpeg' fps = 30)
```
Now we save the animator object as a video file using salva() funzione. Avrai bisogno di uno sceneggiatore cinematografico per salvare il video di animazione. In questo esempio abbiamo utilizzato lo scrittore di filmati FFMPEG. COSÌ scrittore è impostato come "ffmpeg". fps sta per fotogramma al secondo.

Esempio 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 forma a stella si ottiene ponendo k = 2,5 e 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)
```

Tutto sommato le animazioni sono un ottimo strumento per creare cose straordinarie e molte altre cose possono essere create utilizzandole. Ecco come è possibile generare e salvare grafici animati utilizzando Matplotlib. Crea quiz

TechCodeview

Tracciare grafici in Python | Insieme 3