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:
ArtistAnimation. I focus on
FuncAnimation as this is the more intuitive and more widely used one of the two.
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
- Set up
- Initialize data
- Define your animation function –
- Pass everything to
- 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
# 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
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
# 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
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,
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
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)
FuncAnimation object. First, pass the
animate function as positional arguments.
Next, set the number of
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.
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.
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.
- Matplotlib 3D Plot – Full Tutorial
- Matplotlib Boxplot – A Helpful Illustrated Guide
- Matplotlib Legend
- Matplotlib Imshow
- Matplotlib Subplot and Subplots
- Matplotlib Lineplot
- Matplotlib Scatter Plot
- Matplotlib Histogram
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.
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:
%matplotlib notebookmagic command, or
- Changing the
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:
Let’s see what happens when you set
plt.rcParams to those options. First, let’s look at
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
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:
plt.rcParams['animation.html'] = 'jshtml' anim
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.
plt.rcParams at the top of your code.
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!
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.