5 Best Ways to Dynamically Update Plots in Jupyter IPython

Rate this post

πŸ’‘ Problem Formulation: Data scientists and analysts often require real-time visualization to interpret their data better. In Jupyter IPython notebooks, it’s crucial to update plots dynamically without re-running entire cells. This article addresses the problem of keeping data visualizations interactive and current as data changes, with an emphasis on plotting libraries compatible with the Jupyter ecosystem. The desired output is a seamless, dynamic update to a plot when the underlying data is modified.

Method 1: Using Matplotlib FuncAnimation

Matplotlib’s FuncAnimation class allows users to create animated plots that can be updated in real-time. It’s useful for creating simple dynamic visualizations that require periodic updates. The function inside FuncAnimation redraws the plot at specified intervals, which can be controlled with parameters.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-')

def update(frame):
    ln.set_data(xdata, ydata)
    return ln,

ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
                    blit=True, interval=50)


Output: An updating sine wave plot is displayed in a Jupyter notebook cell.

This code snippet sets up a blank plot and defines an update function that appends data to our plot data lists and updates the plot’s data. The FuncAnimation takes this function and periodically calls it with frames of data (in this case, values from 0 to 2*np.pi), resulting in an animated plot.

Method 2: Using IPython.display with clear_output

The IPython.display module provides the clear_output function which can clear the output of a Jupyter cell. By combining this with a plot call within a loop, you can create a dynamic plot that updates within a single cell.

Here’s an example:

import time
from IPython.display import clear_output
import matplotlib.pyplot as plt

for i in range(10):
    plt.plot([0, i], [0, i**2])
    plt.xlim(0, 10)
    plt.ylim(0, 100)

Output: A line plot within the Jupyter cell updates every second, showing a growing line.

This snippet creates a simple loop where each iteration updates the plot. The clear_output(wait=True) ensures the previous output is cleared just before the next plot is drawn, which creates a sense of animation. The time.sleep(1) pauses the loop to allow visualization of each plot.

Method 3: Using Plotly’s graph_objs

Plotly’s graph_objs provide an elegant and interactive way to dynamically update plots in Jupyter notebooks. By using Plotly’s FigureWidget, you can create responsive plots that can be updated in real-time with changing data inputs.

Here’s an example:

import plotly.graph_objs as go
import numpy as np

# Create a figure with initial data
trace = go.Scatter(y=np.random.randn(100))
fig = go.FigureWidget(data=[trace])

# Update the plot with new data
for i in range(10):
    # Assuming you have new data to append to y
    fig.data[0].y = np.random.randn(100)

Output: A Plotly dynamic scatter plot that updates every second with new random data.

With Plotly’s FigureWidget, you can initialize a plot and dynamically change its data properties. In this example, we update the ‘y’ data of the plot with new random numbers every second. This creates a dynamic plot without needing to clear the cell’s output explicitly.

Method 4: Using Bokeh Streaming

Bokeh is another powerful plotting library that integrates well with Jupyter notebooks for creating dynamic visualizations. Its streaming capabilities allow you to seamlessly update plots with streaming data.

Here’s an example:

from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource
from bokeh.io import push_notebook
import numpy as np


source = ColumnDataSource(data=dict(x=[], y=[]))
fig = figure()
fig.line(source=source, x='x', y='y')

def update_plot(new_data):

# Suppose you call update_plot inside a loop or a data callback

Output: A Bokeh plot in a Jupyter notebook that can be dynamically updated with streaming data.

The update_plot function defined above takes new data and streams it to the ColumnDataSource that backs a Bokeh plot. The push_notebook() call updates the notebook output with the new data without refreshing the entire plot.

Bonus One-Liner Method 5: Interactive Widgets with ipywidgets

Interactive IPython widgets from the ipywidgets package can be employed to add interactivity to Jupyter notebook plots. With widgets, you can create controls like sliders or buttons that can change the plot dynamically.

Here’s an example:

import ipywidgets as widgets
from IPython.display import display
import matplotlib.pyplot as plt
import numpy as np

@widgets.interact(x=(0, 10))
def update(x=5):
    plt.plot([0, x], [0, x**2])
    plt.xlim(0, 10)
    plt.ylim(0, 100)

Output: A simple interactive plot with a slider widget to adjust the plot’s end-point in real-time.

This short example uses the @widgets.interact decorator to create an interactive slider that updates the plot. The update function generates a new plot each time the slider value changes and the plot refreshes inline.


  • Method 1: Matplotlib FuncAnimation. Strengths: Well-integrated with Matplotlib, good for animations. Weaknesses: Can be less responsive with complex animations or large data sets.
  • Method 2: IPython.display with clear_output. Strengths: Simple, doesn’t require additional libraries. Weaknesses: Not as smooth or as rich in features as some other methods.
  • Method 3: Plotly’s graph_objs. Strengths: Interactive and responsive, with a rich set of features. Weaknesses: Requires understanding of Plotly’s data structures.
  • Method 4: Bokeh Streaming. Strengths: Great for streaming data and real-time updates. Weaknesses: Requires Bokeh server when dealing with very frequent updates.
  • Bonus Method 5: ipywidgets. Strengths: Easy to use, very interactive. Weaknesses: Limited to the provided widget controls.