I think bind is doing too much work here. What about partial is used here to pass arguments to the update method - which separately is kind of confusing since this update method only takes one argument,

So, would increasing the number of arguments be better?

I think it could make it clearer what partial is doing here

I guess I'm a good guinea pig for this, as I don't really know what partial is supposed to do. After this I am still mystified 😉. Why wouldn't I just pass update directly here? I don't see where offset ever gets used, so I don't see what the -0.5 means.

Ah, my bad. I forgot to update update(), I'll make this clearer.

This should address my issue too

This example is also using closures (as update is closing over xdata and ydata). Maybe keep this example dropping the partial to show the closure and switch this example to something like:

def update(frame, x, y):
    x.append(...)
    y.append(....)
    ...

xdata = []
ydata = []
ani = FuncAnimation(fig, partial(update, x=xdata, y=ydata), ...)

This makes more sense, thanks for the input

Aren't we using partial here?

Not that I can see...

Sorry, I got confused with the example below

This is just wrong isn't it? you are appending to x and y and then setting the data with xdata and ydata. I guess I am never clear if x and y are references or not, but at the very least this is confusing...

I thought the same, hence the use of offset, should I revert to that instead?

I don't know. I'd not do it this way, so whoever would do it this way should write the doc ;-)

@tacaswell Suggested the example, would this be better instead :

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

fig, ax = plt.subplots()
ln, = plt.plot([], [], 'ro')

def init():
   ax.set_xlim(0, 2*np.pi)
   ax.set_ylim(-1, 1)
   return ln,

def update(frame, x_offset=0, y_offset=0):
   xdata.append(frame+x_offset)
   ydata.append(np.sin(frame)+y_offset)
   ln.set_data(xdata, ydata)
   return ln,

x_offset = 2
y_offset = 0.2
ani = FuncAnimation(
fig, partial(update, x_offset=x_offset, y_offset=y_offset),
frames=np.linspace(0, 2 * np.pi, 128),
init_func=init, blit=True)

plt.show()

I mean the above looks better to me. But I don't understand, at all, why we wouldn't just use globals here. If an example where this is practically better than just using a global, we should write such an example.