Interactivity

🎬 Matplotlib Interactivity: Bringing Your Charts to Life!

Imagine your chart is like a puppet show. Right now, your puppets (the graphs) just sit there. But what if they could move, dance, and respond when you poke them? That’s what interactivity does!

🎭 The Puppet Theater Analogy

Think of Matplotlib interactivity like running a puppet theater:

• Backends = The stage (where the show happens)
• Event Handling = The strings you pull when someone claps
• Widgets = Control buttons backstage
• Animation = Making puppets move smoothly
• Saving Animation = Recording the show to watch later

1. 🎪 Backends and Modes

What’s a Backend?

A backend is like choosing WHERE your puppet show happens:

• In a theater (interactive window)
• On TV (saved as a file)
• On a poster (static image)

import matplotlib
# Check your current "stage"
print(matplotlib.get_backend())

# Switch to interactive stage
matplotlib.use('TkAgg')

Two Types of Backends

graph TD
    A["Matplotlib Backends"] --> B["Interactive"]
    A --> C["Non-Interactive"]
    B --> D["TkAgg - Desktop window"]
    B --> E["Qt5Agg - Fancy desktop"]
    B --> F["WebAgg - In browser"]
    C --> G["Agg - PNG images"]
    C --> H["PDF - PDF files"]
    C --> I["SVG - Vector graphics"]

Interactive Mode: ON or OFF?

import matplotlib.pyplot as plt

# Turn ON - charts appear instantly!
plt.ion()

# Turn OFF - charts wait for show()
plt.ioff()

# Check current mode
plt.isinteractive()  # True or False

Simple Rule:

• plt.ion() = “Show me RIGHT NOW!”
• plt.ioff() = “Wait until I say show()”

2. 🎯 Event Handling Basics

What’s an Event?

An event is when something happens:

• You click the chart
• You move the mouse
• You press a key

It’s like your chart saying: “Hey! Someone touched me!”

The Event Handler Recipe

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [1, 4, 9])

# Step 1: Create a function to respond
def on_click(event):
    print(f"You clicked at: "
          f"x={event.xdata}, y={event.ydata}")

# Step 2: Connect the function to clicks
fig.canvas.mpl_connect(
    'button_press_event',
    on_click
)

plt.show()

Common Events You Can Catch

Reading Event Information

def my_handler(event):
    # Where was the click?
    print(event.xdata, event.ydata)

    # Which mouse button?
    print(event.button)  # 1=left, 3=right

    # Which key was pressed?
    print(event.key)

3. 🎛️ Interactive Widgets

What Are Widgets?

Widgets are control buttons for your chart. Like a TV remote, but for graphs!

The Slider Widget

A slider lets you drag to change values:

import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
import numpy as np

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)

# Initial plot
x = np.linspace(0, 10, 100)
line, = ax.plot(x, np.sin(x))

# Create slider area
slider_ax = plt.axes([0.2, 0.1, 0.6, 0.03])
freq_slider = Slider(
    slider_ax, 'Frequency',
    0.1, 10.0, valinit=1.0
)

# Update when slider moves
def update(val):
    line.set_ydata(np.sin(freq_slider.val * x))
    fig.canvas.draw_idle()

freq_slider.on_changed(update)
plt.show()

The Button Widget

A button does something when you click it:

from matplotlib.widgets import Button

# Create button area
btn_ax = plt.axes([0.4, 0.02, 0.2, 0.05])
reset_btn = Button(btn_ax, 'Reset')

def reset(event):
    freq_slider.reset()

reset_btn.on_clicked(reset)

More Widgets

graph TD
    A["Matplotlib Widgets"] --> B["Slider"]
    A --> C["Button"]
    A --> D["RadioButtons"]
    A --> E["CheckButtons"]
    A --> F["TextBox"]
    B --> B1["Drag to change values"]
    C --> C1["Click to do action"]
    D --> D1["Pick ONE option"]
    E --> E1["Pick MANY options"]
    F --> F1["Type text input"]

RadioButtons Example

from matplotlib.widgets import RadioButtons

radio_ax = plt.axes([0.02, 0.4, 0.15, 0.15])
radio = RadioButtons(
    radio_ax,
    ['red', 'blue', 'green']
)

def change_color(label):
    line.set_color(label)
    fig.canvas.draw_idle()

radio.on_clicked(change_color)

4. 🎬 Animation Basics

What’s Animation?

Animation is showing many pictures quickly to make things look like they’re moving. Like a flipbook!

The FuncAnimation Recipe

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

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))

# The update function runs for each frame
def animate(frame):
    line.set_ydata(np.sin(x + frame/10))
    return line,

# Create animation
ani = animation.FuncAnimation(
    fig,           # The figure
    animate,       # Update function
    frames=100,    # Total frames
    interval=50,   # Milliseconds per frame
    blit=True      # Faster drawing
)

plt.show()

How FuncAnimation Works

graph TD
    A["FuncAnimation Starts"] --> B["Frame 0"]
    B --> C["Call animate 0"]
    C --> D["Draw changes"]
    D --> E["Wait interval ms"]
    E --> F["Frame 1"]
    F --> G["Call animate 1"]
    G --> H["Draw changes"]
    H --> I["... repeat ..."]

Key Parameters Explained

Another Animation Example

# Bouncing ball animation
fig, ax = plt.subplots()
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)

ball, = ax.plot([], [], 'ro', markersize=20)
y_pos = [5]
velocity = [0.5]

def animate(frame):
    y_pos[0] += velocity[0]
    # Bounce off walls
    if y_pos[0] >= 9 or y_pos[0] <= 1:
        velocity[0] *= -1
    ball.set_data([5], [y_pos[0]])
    return ball,

ani = animation.FuncAnimation(
    fig, animate,
    frames=200, interval=30, blit=True
)
plt.show()

5. 💾 Animation Saving

Why Save Animations?

You can’t always run Python to show your animation. Saving lets you:

• Share as a video file
• Put in a presentation
• Post on social media

Saving as GIF

# After creating animation...
ani.save(
    'my_animation.gif',
    writer='pillow',
    fps=20
)

Saving as MP4 Video

ani.save(
    'my_animation.mp4',
    writer='ffmpeg',
    fps=30
)

Writers You Can Use

graph TD
    A["Animation Writers"] --> B["pillow"]
    A --> C["ffmpeg"]
    A --> D["imagemagick"]
    A --> E["html"]
    B --> B1["Makes GIF files"]
    C --> C1["Makes MP4/AVI videos"]
    D --> D1["Makes GIF files"]
    E --> E1["Makes HTML5 video"]

Complete Save Example

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

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))

def animate(frame):
    line.set_ydata(np.sin(x + frame/10))
    return line,

ani = animation.FuncAnimation(
    fig, animate,
    frames=50, interval=50, blit=True
)

# Save it!
ani.save(
    'sine_wave.gif',
    writer='pillow',
    fps=20,
    dpi=100
)
print("Saved!")

Save Parameters

🎉 Quick Summary

You just learned how to make your charts come alive!

1. Backends = Choose where your chart lives
2. Events = React when users click/move/type
3. Widgets = Add sliders, buttons, controls
4. Animation = Make things move smoothly
5. Saving = Keep your animation forever

🚀 Your Turn!

Try this starter code:

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

# Create a simple growing circle
fig, ax = plt.subplots()
ax.set_xlim(-2, 2)
ax.set_ylim(-2, 2)
circle = plt.Circle((0,0), 0.1, color='blue')
ax.add_patch(circle)

def grow(frame):
    size = 0.1 + frame * 0.02
    circle.set_radius(size)
    return circle,

ani = animation.FuncAnimation(
    fig, grow,
    frames=50, interval=100
)
plt.show()

You did it! Your charts are no longer just pictures—they’re alive! 🎭✨