Link to booklet is copied to clipboard!

Saved to booklet!

Removed from booklet!

Started capturing to booklet.

Stopped capturing to booklet.

Preferring latest booklet.

No longer prefers latest booklet.

Entered edit mode.

Exited edit mode.

Here is a simple illustration of how to make an animation with matplotlib.
Some big chunks of code will be given in this section, and then every
bit will be explained in the next section.
We start by generating some data and plotting it as usual:

import numpy as np import matplotlib.pyplot as plt plt.rc('font', size=16) N = 101 xs = np.linspace(0,90,N) ys = (100-((xs+10)%20-10)**2) * np.exp(-xs/30) xs = xs * np.exp(-xs/200) fig, ax = plt.subplots(figsize=(4, 6)) ax.axis('equal') ax.plot(xs,ys)

which produces this figure:

Now to make an animation, we must import and use the *Matplotlib*:

`animation`

module from from matplotlib import animation plt.rc('animation', html='jshtml') ball = ax.plot([],[],'ro')[0] def update(i): ball.set_data(xs[i],ys[i]) return [ball] anim = animation.FuncAnimation(fig, update, frames=N, interval=10, blit=True) anim

where the final *Jupyter Notebook* like this (*You cannot click on the buttons of the widget in this book - only in the Jupyter Notebook*):

`anim`

evaluation creates an animation widget that opens in the
That behaves like this:

Lets take the steps in the creation of the animation one by one. First, the

`animation`

module is imported
and some display setting is changed which enables the Jupyter Notebook to render the animation in a browser:
from matplotlib import animation plt.rc('animation', html='jshtml')

Next, a

`matplotlib.lines.Line2D`

object is created when
calling `ax.plot`

. The object is to become a red filled
circle because of the `'ro'`

argument, but
to begin with it has no - or -coordinates (because of the
two empty list, `[]`

, arguments,
and will hence not show
up yet. Note the `[0]`

that picks the first element of
the list returned by `ax.plot`

:
ball = ax.plot([],[],'ro')[0]

`ball`

is now a `update`

, that takes an index `i`

as an argument and changes the and
coordinates of the red filled circle to the 'th value in the two lists, `xs`

and `ys`

:
def update(i): ball.set_data(xs[i],ys[i]) return [ball]

Note how
Now, all that remains to get the animation is to make the animation object like this:

`update`

returns `ball`

as the only
element in a list
of drawing objects, i.e. it returns `[ball]`

and not just
`ball`

.
anim = animation.FuncAnimation(fig, # figure canvas as returned by plt.subplots() update, # update and return a list of drawing objects frames=N, # i in range(N), i passed to update interval=10, # delay between frames in ms blit=True) anim

where the

`FuncAnimation`

method calls our `update`

function `frames=N`

times
with the arguments from to , whereby the red filled circle gets all the calculated coordinates one by one. When
the call of `update`

returns with the list `[ball]`

, `FuncAnimation`

is advised
that the drawing object `ball`

has changed and should be redrawn in the figure.
The animation can be stored as an animated gif-file with the following method. First we
check for the availability of an animation-write:

print('Available writers:', animation.writers.list())

Available writers: ['pillow', 'html']

and if

`'pillow'`

is present, one may proceed with these two commands:
writer = animation.writers['pillow'](fps=50) # frames per second anim.save('bouncing_ball.gif', writer=writer)

If

`'pillow'`

is absent, you'll need to install it on your system.
Figure elements of any shape may be animated. Here is an example for a
square that has one corner at the origin, side lengths of , and an
angle to the -axis of :

Naming the four corners

`P0`

,
`P1`

,
`P2`

,
and
`P3`

, the coordinates for a given angle
may be calculated with
the `xy_of_theta`

function as defined here:
%matplotlib inline import numpy as np import matplotlib.pyplot as plt np.set_printoptions(precision=3) plt.rc('font', size=16) def xy_of_theta(theta): vec1 = np.array([np.cos(theta),np.sin(theta)]) vec2 = np.array([-np.sin(theta),np.cos(theta)]) P0 = [0,0] P1 = vec1 P2 = vec1 + vec2 P3 = vec2 x_of_theta = [P0[0],P1[0],P2[0],P3[0],P0[0]] y_of_theta = [P0[1],P1[1],P2[1],P3[1],P0[1]] return x_of_theta,y_of_theta

Note how the coordinates of

`P0`

appear both at the beginning and at the
end of the returned coordinate lists. This means that the square can
be plotted with Matplotlibs
`pyplot.plot`

function as done here:
fig, ax = plt.subplots() ax.axis('equal') ax.grid() ax.set_xlim(-3,3) ax.set_ylim(-2,2) ax.set_yticks(range(-1,2)) xs, ys = xy_of_theta(np.pi/6) square = ax.plot(xs,ys)[0]

When the square is plotted with

`plot`

, the first element
of the returned list is captured in `square`

which
reveals that it is a Line2D object:
square

<matplotlib.lines.Line2D at 0x7fbc989f7850>

One may inspect the coordinates of the Line2D object with its

`get_data`

method:
square.get_data()

(array([ 0. , 0.866, 0.366, -0.5 , 0. ]), array([0. , 0.5 , 1.366, 0.866, 0. ]))

And the coordinates may be altered with the

`set_data`

method:
xs, ys = xy_of_theta(np.pi/3) # new angle square.set_data((xs,ys)) fig

The

`set_data`

method can be used to make an animation,
where the square is being rotated:
from matplotlib import animation plt.rc('animation', html='jshtml') N = 50 def update(i): theta = i * 2*np.pi/N xs, ys = xy_of_theta(theta) square.set_data((xs,ys)) return [square] anim = animation.FuncAnimation(fig, update, frames=N, interval=10, blit=True) anim

Note, that this time, the counter,

`i`

, is used to
calculate a new angle that the first side of the square forms with the -axis.
Once deleted this booklet is gone forever!

Choose which booklet to go to: