Matplotlib Slider not updating? Fix callback scope issues by passing values to helper functions

Learn why the Matplotlib Slider in Python freezes when callbacks split across functions, and how to fix scope bugs by passing values explicitly. Clear example.

Interactive plotting with matplotlib’s Slider looks straightforward until you split your callback logic across functions. A common pitfall emerges when a helper function reads a variable you expect to be updated by the Slider, but the plot stays frozen at its initial state. Let’s go through a minimal example of this scope trap and fix it properly.

Reproducing the issue

The goal is to update a sine curve’s frequency via a Slider. The plot updates only if all logic lives inside the Slider’s callback. Once the update is delegated to a separate function, the line no longer changes.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
xgrid = np.linspace(400, 800, 400)
figure, axis_main = plt.subplots()
figure.subplots_adjust(bottom=0.25)
factor = 1.0
wave_line, = axis_main.plot(xgrid, np.sin(factor * xgrid * 2 * np.pi / 500))
slider_axis = figure.add_axes([0.3, 0.1, 0.5, 0.04])
freq_slider = Slider(
    ax=slider_axis,
    label="modulation",
    valmin=0,
    valmax=20,
    valinit=1.0,
    orientation="horizontal"
)
def on_freq_change(val):
    factor = freq_slider.val
    update_curve()
    figure.canvas.draw_idle()
def update_curve():
    wave_line.set_ydata(np.sin(factor * xgrid * 2 * np.pi / 500))
freq_slider.on_changed(on_freq_change)
plt.show()

What actually happens

The helper function reads a name that is not defined in its local scope. In the example above, update_curve() uses factor. Because factor isn’t passed to update_curve() and isn’t declared otherwise, Python looks outside and finds the module-level factor = 1.0. That value never changes. Inside the callback on_freq_change(), assigning factor = freq_slider.val creates a new local variable named factor, which does not affect the module-level one. As a result, update_curve() always sees the original factor.

Fixing the callback flow

Pass the value explicitly to the helper function. This makes the data flow unambiguous and ensures the plot reflects the current Slider value.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
xgrid = np.linspace(400, 800, 400)
figure, axis_main = plt.subplots()
figure.subplots_adjust(bottom=0.25)
factor = 1.0
wave_line, = axis_main.plot(xgrid, np.sin(factor * xgrid * 2 * np.pi / 500))
slider_axis = figure.add_axes([0.3, 0.1, 0.5, 0.04])
freq_slider = Slider(
    ax=slider_axis,
    label="modulation",
    valmin=0,
    valmax=20,
    valinit=1.0,
    orientation="horizontal"
)
def refresh_curve(current_factor):
    wave_line.set_ydata(np.sin(current_factor * xgrid * 2 * np.pi / 500))
def on_freq_change(val):
    current = freq_slider.val
    refresh_curve(current)
    figure.canvas.draw_idle()
freq_slider.on_changed(on_freq_change)
plt.show()

This version updates the line correctly because refresh_curve() receives the exact value to use, rather than relying on outer-scope lookup. Another approach that also works is declaring the variable as global in the callback, but passing values explicitly keeps dependencies clear and localized.

Why this matters

Callbacks and scopes intersect frequently in interactive plotting: as your figure grows and the UI logic spreads into helpers, the reliance on implicit name resolution becomes brittle. Passing values directly avoids silent bugs where the UI seems responsive but the plot reflects an outdated state. It also makes refactoring easier, because each function advertises its inputs and no longer depends on ambient state.

Conclusion

When building dynamic matplotlib visuals with Slider, watch out for variable scope. If a helper needs the Slider’s current value, pass it in. This small discipline keeps your callbacks predictable, your plots accurate, and your codebase easier to scale when the math behind the curve becomes more involved.