Tutorial on the Matplotlib Radio Buttons in Python

The RadioButtons widget in Matplotlib provides an easy way to create interactive radio buttons that can be used to toggle between various plot configurations, update data, or switch between views.

This widget is a part of matplotlib.widgets and allows you to add interactivity to your plots, making it great for dynamic visualizations.

In this tutorial, we’ll cover the basics of creating and using radio buttons in Matplotlib, along with examples to demonstrate different applications.

1. Setting Up Basic Radio Buttons

Radio buttons allow you to display a list of options, only one of which can be selected at a time. The RadioButtons widget can be set up using matplotlib.widgets.RadioButtons.

Basic Structure of RadioButtons

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

# Sample data
x = np.linspace(0, 2 * np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Create figure and initial plot
fig, ax = plt.subplots()
line, = ax.plot(x, y1, label="sin(x)")
ax.legend()
plt.xlabel("X-axis")
plt.ylabel("Y-axis")

# Create radio buttons
rax = plt.axes([0.7, 0.4, 0.15, 0.15], frameon=True)  # Location of radio buttons
radio = RadioButtons(rax, ('sin(x)', 'cos(x)'))

# Define callback function to update plot
def update_plot(label):
    if label == 'sin(x)':
        line.set_ydata(y1)
    elif label == 'cos(x)':
        line.set_ydata(y2)
    line.set_label(label)
    ax.legend()
    plt.draw()

# Link radio buttons to callback function
radio.on_clicked(update_plot)
plt.show()

In this example:

• RadioButtons are created in the specified position (rax).
• The update_plot function changes the data shown in the plot based on the selected option.
• radio.on_clicked(update_plot) connects the radio button selection to the callback function.

2. Customizing Radio Buttons Appearance

The appearance of radio buttons can be customized with options like activecolor and by changing the font properties.

# Customize radio button colors and fonts
fig, ax = plt.subplots()
line, = ax.plot(x, y1, label="sin(x)")
ax.legend()

# Radio buttons with customized appearance
rax = plt.axes([0.7, 0.4, 0.15, 0.15], frameon=True)
radio = RadioButtons(rax, ('sin(x)', 'cos(x)'), activecolor='orange')

# Set font properties of labels
for label in radio.labels:
    label.set_fontsize(12)
    label.set_color('blue')

# Callback function
def update_plot(label):
    if label == 'sin(x)':
        line.set_ydata(y1)
    elif label == 'cos(x)':
        line.set_ydata(y2)
    line.set_label(label)
    ax.legend()
    plt.draw()

# Link radio buttons to callback
radio.on_clicked(update_plot)
plt.show()

In this example:

• activecolor='orange' sets the color of the active radio button.
• label.set_fontsize and label.set_color change the font size and color of the labels.

3. Switching Between Multiple Data Sets with Radio Buttons

Radio buttons can be used to switch between different datasets on the same plot. Here’s an example where we toggle between three different functions.

# Additional data
y3 = np.tan(x)

# Create plot
fig, ax = plt.subplots()
line, = ax.plot(x, y1, label="sin(x)")
ax.legend()

# Create radio buttons
rax = plt.axes([0.7, 0.3, 0.15, 0.2], frameon=True)
radio = RadioButtons(rax, ('sin(x)', 'cos(x)', 'tan(x)'))

# Callback function to update plot
def update_plot(label):
    if label == 'sin(x)':
        line.set_ydata(y1)
    elif label == 'cos(x)':
        line.set_ydata(y2)
    elif label == 'tan(x)':
        line.set_ydata(np.where(np.abs(y3) < 10, y3, np.nan))  # Handle large values in tan
    line.set_label(label)
    ax.legend()
    plt.draw()

radio.on_clicked(update_plot)
plt.show()

In this example:

• We add a third option, tan(x), and filter extreme values to avoid large jumps in the plot.

4. Using Radio Buttons to Toggle Plot Properties

Radio buttons can also be used to change plot properties like color, line style, and line width dynamically.

# Create plot with initial line style and color
fig, ax = plt.subplots()
line, = ax.plot(x, y1, label="sin(x)", color='blue', linestyle='-', linewidth=2)
ax.legend()

# Radio buttons for color, line style, and width
color_ax = plt.axes([0.7, 0.7, 0.15, 0.15], frameon=True)
color_radio = RadioButtons(color_ax, ('blue', 'green', 'red'), activecolor='blue')

style_ax = plt.axes([0.7, 0.5, 0.15, 0.15], frameon=True)
style_radio = RadioButtons(style_ax, ('-', '--', '-.'), activecolor='green')

width_ax = plt.axes([0.7, 0.3, 0.15, 0.15], frameon=True)
width_radio = RadioButtons(width_ax, ('1', '2', '3'), activecolor='purple')

# Callback functions to update line properties
def update_color(label):
    line.set_color(label)
    plt.draw()

def update_style(label):
    line.set_linestyle(label)
    plt.draw()

def update_width(label):
    line.set_linewidth(int(label))
    plt.draw()

# Connect radio buttons to callback functions
color_radio.on_clicked(update_color)
style_radio.on_clicked(update_style)
width_radio.on_clicked(update_width)
plt.show()

In this example:

• Three groups of radio buttons control color, line style, and line width of the plot.
• Separate callback functions are used for each property.

5. Using Radio Buttons with Subplots

Radio buttons can also be used to control multiple subplots, allowing you to interact with different sections of a larger figure.

# Create subplots with different data
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 8))
x = np.linspace(0, 2 * np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)

# Plot initial data in both subplots
line1, = ax1.plot(x, y1, label="sin(x)")
line2, = ax2.plot(x, y2, label="cos(x)")
ax1.legend()
ax2.legend()

# Create radio buttons
rax = plt.axes([0.7, 0.4, 0.15, 0.15], frameon=True)
radio = RadioButtons(rax, ('sin(x)', 'cos(x)', 'tan(x)'))

# Callback function to update both subplots
def update_subplots(label):
    if label == 'sin(x)':
        line1.set_ydata(y1)
        line2.set_ydata(y1)
    elif label == 'cos(x)':
        line1.set_ydata(y2)
        line2.set_ydata(y2)
    elif label == 'tan(x)':
        line1.set_ydata(np.where(np.abs(y3) < 10, y3, np.nan))
        line2.set_ydata(np.where(np.abs(y3) < 10, y3, np.nan))
    
    line1.set_label(label)
    line2.set_label(label)
    ax1.legend()
    ax2.legend()
    plt.draw()

radio.on_clicked(update_subplots)
plt.show()

In this example:

• Both subplots are updated based on the selected option in the radio button.

6. Using Radio Buttons to Toggle Visibility of Multiple Lines

Radio buttons can be used to selectively show or hide lines in a plot by adjusting their visibility.

# Data setup for multiple lines
x = np.linspace(0, 2 * np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)

# Create plot with multiple lines
fig, ax = plt.subplots()
line1, = ax.plot(x, y1, label="sin(x)")
line2, = ax.plot(x, y2, label="cos(x)")
line3, = ax.plot(x, np.where(np.abs(y3) < 10, y3, np.nan), label="tan(x)")
ax.legend()

# Create radio buttons to toggle line visibility
rax = plt.axes([0.75, 0.3, 0.15, 0.3], frameon=True)
radio = RadioButtons(rax, ('sin(x)', 'cos(x)', 'tan(x)'))

# Callback function to toggle line visibility
def toggle_visibility(label):
    line1.set_visible(label == 'sin(x)')
    line2.set_visible(label == 'cos(x)')
    line3.set_visible(label == 'tan(x)')
    ax.legend()
    plt.draw()

radio.on_clicked(toggle_visibility)


plt.show()

In this example:

• Each radio button toggles the visibility of one line, hiding the others.

Summary

This tutorial covered how to use the RadioButtons widget in Matplotlib to add interactive functionality to your plots. We explored:

1. Basic radio button setup.
2. Customizing the appearance of radio buttons.
3. Switching between multiple datasets.
4. Using radio buttons to change plot properties (color, style, width).
5. Controlling multiple subplots with radio buttons.
6. Toggling visibility of multiple lines.