Matplotlib Animation – A Helpful Illustrated Guide

Creating animations in matplotlib is reasonably straightforward. However, it can be tricky when starting, and there is no consensus for the best way to create them. In this article, I show you a few methods you can use to make amazing animations in matplotlib.

Matplotlib Animation Example

The hardest thing about creating animations in matplotlib is coming up with the idea for them. This article covers the basic ideas for line plots, and I may cover other plots such as scatter and 3D plots in the future. Once you understand these overarching principles, you can animate other plots effortlessly.

There are two classes you can use to create animations: FuncAnimation and ArtistAnimation. I focus on FuncAnimation as this is the more intuitive and more widely used one of the two.

To use FuncAnimation, define a function (often called animate), which matplotlib repeatedly calls to create the next frame/image for your animation.

To create an animation with FuncAnimation in matplotlib, follow these seven steps:

Have a clear picture in your mind of what you want the animation to do
Import standard modules and FuncAnimation
Set up Figure, Axes, and Line objects
Initialize data
Define your animation function – animate(i)
Pass everything to FuncAnimation
Display or save your animation

Let’s create a sin wave that matplotlib ‘draws’ for us. Note that this code may look strange to you when you first read it. Creating animations with matplotlib is different from creating static plots.

# Standard imports
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

Import NumPy and matplotlib using their standard aliases and FuncAnimation from matplotlib.animation.

# Set up empty Figure, Axes and Line objects
fig, ax = plt.subplots()
# Set axes limits so that the whole image is included
ax.set(xlim=(-0.1, 2*np.pi+0.1), ylim=(-1.1, 1.1))
# Draw a blank line
line, = ax.plot([], [])

Set up the Figure and Axes objects using plt.subplots() and – using ax.set() – set the x- and y-axis limits to the same size as a normal sine curve – from 0 to 2π on the x-axis and from -1 to 1 on the y-axis. Note that I included padding of 0.1 on each axis limit so that you can see the whole line matplotlib draws.

Then, I did something you have probably never done before: I drew a blank line. You need to do this because animate modifies this line, and it can only modify something that already exists. You can also think of it as initializing an empty line object that you will soon fill with data.

Note that you must include a comma after line,! The plot method returns a tuple, and you need to unpack it to create the variable line.

# Define data - one sine wave
x = np.linspace(0, 2*np.pi, num=50)
y = np.sin(x)

Next, define the data you want to plot. Here, I am plotting one sine wave, so I used np.linspace() to create the x-axis data and created y by calling np.sin() on x. Thanks to numpy broadcasting, it is easy to apply functions to NumPy arrays!

# Define animate function
def animate(i):
    line.set_data(x[:i], y[:i])
    return line,

Define the animate(i) function. Its argument i is an integer starting from 0 and up to the total number of frames you want in your animation. I used the line.set_data() method to draw the first i elements of the sine curve for both x and y. Note that you return line, with a comma again because you need to return an iterable and adding a comma makes it a tuple.

# Pass to FuncAnimation
anim = FuncAnimation(fig, animate, frames=len(x)+1, interval=30, blit=True)

Create a FuncAnimation object. First, pass the Figure and animate function as positional arguments.

Next, set the number of frames to len(x)+1 so that it includes all the values in x. It works like the range() function, and so even though x has length 50, python only draws frames 0 to 49 and not the 50th member. So, add on one more to draw the entire plot.

The interval is how long in milliseconds matplotlib waits between drawing the next part of the animation. I’ve found that 30 works well as a general go-to. A larger number means matplotlib waits longer between drawing and so the animation is slower.

Finally, set blit=True so that it only redraws parts that have not been drawn before. It doesn’t make much difference for this example, but once you create more complex plots, you should use this; it can take quite a while for matplotlib to create animations (waiting several minutes is common for large ones).

# Save in the current working directory
anim.save('sin.mp4')

I saved the animation as a video called ‘sin.mp4’ to the current working directory.

Open your current working directory, find the saved video, and play it. Congratulations! You’ve just made your first animation in matplotlib!

Some of the steps you take to create animations are unique and may feel unusual the first time you try them. I know I felt strange the first time I used them. Don’t worry, the more you practice and experiment, the easier it becomes.

Here’s the full code:

# Standard imports
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Set up empty Figure, Axes and Line objects
fig, ax = plt.subplots()
# Set axes limits so that the whole image is included
ax.set(xlim=(-0.1, 2*np.pi+0.1), ylim=(-1.1, 1.1))
# Draw a blank line
line, = ax.plot([], []) 

# Define data - one sine wave
x = np.linspace(0, 2*np.pi, num=50)
y = np.sin(x)

# Define animate function
def animate(i):
    line.set_data(x[:i], y[:i])
    return line,

# Pass to FuncAnimation
anim = FuncAnimation(fig, animate, frames=len(x)+1, interval=30, blit=True)

# Save in the current working directory
anim.save('sin.mp4')

Note that if this final step did not work for you, it’s probably because you don’t have the right libraries installed – I’ll show you what to install right now.

Related:

Matplotlib Animation Save

To save your animation in matplotlib, use the .save() method on your FuncAnimation object. You can either save them as mp4 videos or gifs.

Matplotlib Animation Save Mp4

To save animations as mp4 videos, first, install the FFmpeg library. It’s an incredibly powerful command-line tool, and you can download it from their official site, Github, or, if you use anaconda, by running conda install ffmpeg.

Once you have created your animation, run anim.save('name.mp4', writer='ffmpeg'), and python saves your animation as the video ‘name.mp4’ in your current working directory.

Note that the default writer is FFmpeg, and so you don’t have to explicitly state it if you don’t want to.

Matplotlib Animation Save Gif

To save animations as gifs, first, install the ImageMagick library. It is a command-line tool, and you can download it from their official site, GitHub, or if you use anaconda, by running conda install -c conda-forge imagemagick.

Once you have created your animation, run anim.save('name.gif', writer='imagemagick'), and python saves your animation as the gif ‘name.gif’ in your current working directory.

anim.save('sin.gif', writer='imagemagick')

Note that both ImageMagick and FFmpeg are command-line tools and not python libraries. As such, you cannot install them using pip. There are some python wrappers for those tools online, but they are not what you need to install.

Matplotlib Animation Jupyter

If you write your code in Jupyter notebooks (something I highly recommend), and don’t want to save your animations to disk every time, you may be disappointed to hear that your animations do not work out of the box. By default, Jupyter renders plots as static png images that cannot be animated.

To fix this, you have a couple of options to choose from:

The %matplotlib notebook magic command, or
Changing the plt.rcParams dictionary

If you run %matplotlib notebook in a code cell at the top of your notebook, then all your plots render in interactive windows.

# Run at the top of your notebook
%matplotlib notebook

As I cannot show you interactive Jupyter windows in a blog post, the above video shows you the result of running the sin drawing curve above.

This method is by far the simplest but gives you the least control. For one thing, the buttons at the bottom do nothing. Plus, it keeps running until you click the off button at the top… but when you do, you have no way to turn it on again!

I much prefer using the default %matplotlin inline style for all my plots, but you are free to choose whichever you want.

The other option is to change the plt.rcParams dictionary. This dictionary controls the default behavior for all your matplotlib plots such as figure size, font size, and how your animations should display when you call them.

If you print it to the screen, you can see all the parameters it controls.

The one you are interested in is animation.html, which is none by default. The other options are: 'html5' and 'jshtml'.

Let’s see what happens when you set plt.rcParams to those options. First, let’s look at 'html5'.

plt.rcParams['animation.html'] = 'html5'
anim

Now the animation is rendered as an HTML5 video that plays as a loop. You can start/stop it using the play/pause buttons, but that’s about it. In my experience, this video plays much smoother than the interactive windows produced by %matplotlib notebook.

Note that the above video is a screen capture of what you see in Jupyter notebooks.

Now let’s look at the much more powerful option: 'jshtml' which stands for Javascript HTML.

plt.rcParams['animation.html'] = 'jshtml'
anim

Now your animations are displayed in interactive javascript windows! This option is by far the most powerful one available to you.

Here are what each of the keys do (starting from the far left):

speed up/slow down: + / –
jump to end/start: |<< / >>|
move one frame backwards/forwards: |< / >|
play it backwards/forwards: < / >
pause with the pause key

Moreover, you can choose to play it ‘Once’, ‘Loop’ infinitely or play forwards and backward indefinitely using ‘Reflect’.

Again note that the above video is a screen capture of what you see in Jupyter notebooks.

To have all your animations render as either HTML5 video or in interactive javascript widgets, set plt.rcParams at the top of your code.

Conclusion

Excellent! You now know how to create basic animations in matplotlib. You know how to use FuncAnimaton, how to save them as videos or gifs, and plot animations in Jupyter notebooks.

You’ve seen how to create ‘drawing’ plots, but there are many other things you can do, such as creating moving plots, animating 3D plots, and even scatter graphs. But we’ll leave them for another article.

Where To Go From Here?

Do you wish you could be a programmer full-time but don’t know how to start?

Check out the pure value-packed webinar where Chris – creator of Finxter.com – teaches you to become a Python freelancer in 60 days or your money back!

https://tinyurl.com/become-a-python-freelancer

It doesn’t matter if you’re a Python novice or Python pro. If you are not making six figures/year with Python right now, you will learn something from this webinar.

These are proven, no-BS methods that get you results fast.

This webinar won’t be online forever. Click the link below before the seats fill up and learn how to become a Python freelancer, guaranteed.

https://tinyurl.com/become-a-python-freelancer