Animation — FuncAnimation: Foundations — Hinglish deep dive

5.4.18 · D1 · Coding › Scientific Computing (Python) › Animation — FuncAnimation

Is page par assume kiya gaya hai ki tum kuch nahi jaante. Line line, = ax.plot([], []) padhne se pehle tumhe jaanna chahiye ki Figure, Axes, artist, set_data, generator, frame, update function, init_func, event loop, aur yahan tak ki akela trailing comma actually kya hain. Hum har ek ko ek picture se build karte hain, us order mein jahan har ek pehle wale par tikaa hota hai, aur ant mein hum sab ko real FuncAnimation(...) call mein wire karke chalate hain.

Recall Required pre-reading vs. self-contained

Ye deep dive self-contained hai: neeche har pitfall aur mechanic yahan poori tarah explain ki gayi hai. Linked notes (jaise Artists in Matplotlib, Generators in Python) optional enrichment hain, prerequisites nahi — tum yeh page bina unhe khole khatam kar sakte ho.

Definition Imports jo is page ke har snippet mein assume hain

Neeche har code block is tarah likha gaya hai jaise ye teen lines file ke upar pehle se run ho chuki hain:

import numpy as np                         # gives us np.linspace, np.sin, np.pi
import matplotlib.pyplot as plt            # gives us plt.subplots, plt.show
from matplotlib.animation import FuncAnimation   # the star of the topic

np aur plt sirf chhote nicknames hain. Jab bhi tum plt.subplots() ya np.sin(...) dekho, yaad rakho ye do libraries se aate hain; FuncAnimation teesri line se aata hai.

0. Woh picture jisme pura topic rehta hai

Cards ka stack → frames ka sequence.
Ek card → ek frame (ek still picture).
Flip karne ki speed → interval (har card kitne time tak dikhaya jaata hai).
"Card n ke liye, dot yahan rakho" ka rule → tumhara update function.
Flip karne wala robot → event loop / timer.

Is figure ko dhyaan mein rakho; har symbol iske upar map hota hai.

1. Canvas: `fig` aur `ax`

Kuch bhi move hone se pehle, hume koi surface chahiye jis par draw kar sakein. Matplotlib ise do nested cheezein mein split karta hai.

Picture mein: pale outer rectangle Figure hai; tick marks wala inner boxed region Axes hai. Code

fig, ax = plt.subplots()   # plt = matplotlib.pyplot (see imports above)

dono ek saath deta hai: fig = paper, ax = us par ek drawing box.

Poori anatomy ke liye dekho Matplotlib Figure and Axes.

2. Woh cheez jo actually draw hoti hai: ek artist

Tum pixels haath se nahi draw karte. Balki, matplotlib tumhe aise objects deta hai jo khud khud draw karna jaante hain. Inhe artists kehte hain.

Jab tum likhte ho

line, = ax.plot([], [])

tum axes par ek Line2D puppet create kar rahe ho. Abhi yeh empty data ([] aur []) hold karta hai, toh kuch draw nahi karta — lekin puppet exist karta hai, bataye jaane ke liye ready ki kahan hona hai.

Line2D, markers, aur blitting ke baare mein aur padhne ke liye Artists in Matplotlib dekho.

3. Puppet ko rebuild kiye bina hilana: `set_data`

Yeh pure topic ka sabse important verb hai.

xs — x-coordinates ki sequence (left-right).
ys — matching sequence of y-coordinates (up-down).
Dono same length ke hone chahiye: point k $(x_{k}, y_{k})$ par hai.

4. Per-frame numbers kahan se aate hain: `linspace` aur phase shift

Poori wave move karne ke liye hume kaafi x-points aur har ek par ek y-value chahiye.

Yahan $π$ (np.pi) sirf $\approx 3.14159$ number hai; $2 π \approx 6.283$ sine wave ka ek full turn hai. Hum $[0, 2 π]$ choose karte hain taaki exactly ek hump-and-trough screen par fit ho.

Wave ko travel karane ke liye, hum likhte hain np.sin(x - 0.1*frame). Subtract kyun?

Kyunki ek NumPy expression sab 400 y-values ek saath compute karta hai, hum NumPy linspace and broadcasting par lean karte hain.

5. Ek still picture ke liye do words: frame aur `frames`

Toh jab tum likhte ho frames=200, update function ko frame = 0, phir 1, … 199 tak milta hai. Jab tum likhte ho frames=frame_gen, generator ka har yielded value frame banta hai.

6. Ek machine jo ek baar mein ek value deti hai: generator

Figure mein, generator ek vending slot hai: har "next!" agla value pop out karta hai ( $t = 0.00$ , phir $0.05$ , phir $0.10$ …) aur phir mid-code freeze ho jaata hai agli request tak.

def frame_gen():
    t = 0.0
    while t < 6.28:
        yield t      # hand out t, then FREEZE here
        t += 0.05    # on next request, resume from here

Deeper mechanics: Generators in Python.

7. Ek card ka rule: update function (`func`)

Ab show ka star. FuncAnimation khud kuch nahi draw karta — woh sirf tumhari function ko har frame mein call karta hai aur us function ko puppets reposition karne deta hai.

Worked example Canonical update function — ek travelling wave

x = np.linspace(0, 2*np.pi, 400)
line, = ax.plot([], [], lw=2)   # puppet made ONCE, outside func
 
def update(frame):              # frame = 0, 1, 2, ... fed in by FuncAnimation
    y = np.sin(x - 0.1*frame)   # this card's y-values (wave shifted right)
    line.set_data(x, y)         # slide the SAME puppet to the new pose
    return line,                # tell blit what changed (1-tuple)

update kabhi tumhare dwara call nahi hota — FuncAnimation ise call karta hai, har tick mein frame hand in karta hua.

8. Clean pehla page: `init_func`

Pehle real frame se bilkul pehle, matplotlib ek jaani pehchani blank starting state chahta hai — flip-book ka cover sochho, "frame 0 se pehle" wali picture.

Worked example Travelling wave ke liye init_func

def init():
    line.set_data([], [])   # empty line = clean background ("before frame 0")
    return line,            # same return contract as update

9. Speed trick: blitting (`blit=True`)

10. Akela comma: `line, = ...` aur `return line,`

Har beginner ko do commas confuse karti hain. Yeh rahi, defused.

11. Robot ki stopwatch: `interval`, FPS, aur event loop

Frames-per-second (ek second mein kitne cards flip hote hain) hai:

$FPS = \frac{1000 \frac{ms}{s}}{interval \frac{ms}{frame}}$

Stopwatch kaun fire karta hai? Event loop.

Dekho Event Loops / GUI backends kyun blocking loops "hung" lagte hain.

12. Sab kuch wire karna: real `FuncAnimation(...)` call

Ab har part exist karta hai. Yeh hai poori signature, phir complete runnable program jo upar har cheez use karta hai.

Definition FuncAnimation constructor

anim = FuncAnimation(fig, func, frames=None, init_func=None,
                     interval=200, blit=False, repeat=True, save_count=None)

fig — redraw karne ke liye persistent Figure (§1).
func — tumhara update function func(frame) (§7). Required.
frames — ek int N, iterable, ya generator (§5–6).
init_func — clean-background function (§8).
interval — frames ke beech ms (§11).
blit — True = sirf returned artists repaint karo (§9).
repeat — frames khatam hone par start par wapas loop karo.
save_count — frames ka cap jo length-unknown generator save karte waqt grab hote hain (§14).

Worked example Complete travelling-wave program (copy-paste runnable)

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()          # §1: one persistent canvas
ax.set_xlim(0, 2*np.pi)           # set limits ONCE so blit can cache background
ax.set_ylim(-1.1, 1.1)
x = np.linspace(0, 2*np.pi, 400)  # §4: the x-points
line, = ax.plot([], [], lw=2)     # §2/§10: puppet made ONCE, empty
 
def init():                       # §8: clean "before frame 0"
    line.set_data([], [])
    return line,
 
def update(frame):                # §7: the per-card rule
    y = np.sin(x - 0.1*frame)
    line.set_data(x, y)
    return line,                  # §9: what blit repaints
 
anim = FuncAnimation(fig, update, frames=200, init_func=init,
                     interval=20, blit=True)   # §12: wire it all
 
plt.show()                        # §13: START the event loop (blocks here)
# anim.save("wave.mp4", fps=50)   # or "wave.gif" — needs ffmpeg / pillow

13. Actually start karna — aur alive rakhna

anim banana khud se kuch move nahi karta; yeh sirf timer register karta hai. Event loop start karna padega.

Movie save karne ke liye tum frames ko ffmpeg (mp4) ya pillow (gif) ko dete ho. Dekho Saving figures and ffmpeg.

14. `save_count` — endless generator ko cap karna

Worked example Generator-driven frames save_count ke saath

def frame_gen():            # §6: yields custom time values, unknown length
    t = 0.0
    while t < 6.28:
        yield t
        t += 0.05
 
def update(t):
    line.set_data(x, np.sin(x - t))
    return line,
 
anim = FuncAnimation(fig, update, frames=frame_gen,
                     init_func=init, interval=30, blit=True,
                     save_count=200)   # grab at most 200 frames when saving
anim.save("wave.mp4", fps=30)

Yahan frame_gen lagbhag $6.28/0.05 \approx 126$ values yield karta hai, toh save_count=200 ek safe upper cap hai — matplotlib tab rukta hai jab generator exhaust ho ya cap hit ho, jo pehle aaye.

Prerequisite map

Equipment checklist

Figure aur Axes mein kya fark hai?

Figure = poora sheet/window; Axes = uske andar ek plotting rectangle (ticks aur grid ke saath).

Artist kya hota hai, aur plotted line kis type ki hoti hai?

Ek self-drawing object jise matplotlib manage karta hai; plotted line ek Line2D hoti hai.

line.set_data(xs, ys) kya karta hai?

Existing line ko in-place naye x/y points par mutate karta hai — same puppet, naya pose.

ax.plot ko update function ke bahar EK BAAR kyun call karein?

Ek artist ko set_data se reuse karne ke liye; ise per frame call karne se naye artists pile up hote hain aur blit toot jaata hai.

np.linspace(0, 2*np.pi, 400) kya produce karta hai?

0 se 2π tak inclusive 400 evenly spaced numbers.

np.sin(x - 0.1*frame) wave ko right kyun move karta hai?

Bada shift peak (input = π/2) ko bade x par push karta hai, toh features right slide karte hain.

Generator kya hai aur yield kya karta hai?

Ek function jo ek value hand back karta hai phir pause karta hai, agli request par resume karta hua.

Update function func kya hai aur iska argument kya hai?

Ek function jo tum likhte ho jo current frame leta hai, set_data se puppets reposition karta hai, aur changed artists return karta hai.

init_func kis kaam aata hai, aur woh kaunsa argument leta hai?

Yeh frame 0 se pehle clean empty background draw karta hai; koi frame argument nahi leta aur artists return karta hai.

FuncAnimation ka doosra positional argument kya hai?

func, tumhara update function.

interval=20 ms ko FPS mein convert karo.

1000/20 = 50 FPS.

Per-frame timer kaun fire karta hai?

GUI event loop, jo window ko bhi responsive rakhta hai.

Screen par animation actually START kaise karte ho?

plt.show() call karo, jo event loop chalata hai (aur window band hone tak block karta hai).

blit=True ke saath, func (aur init_func) ko kya return karna chahiye?

Changed artists ka ek iterable, jaise return line,.

line, = ax.plot(...) mein trailing comma kya karta hai?

ax.plot return karne wali single-element list ko line mein unpack karta hai.

anim = FuncAnimation(...) kyun rakhna zaroori hai?

Warna yeh garbage-collect ho jaata hai, timer ruk jaata hai, aur animation freeze/blank ho jaati hai.

save_count kis kaam aata hai?

Generator-driven animation SAVE karte waqt kitne frames grab karne hain iska cap; live playback ke dauran ignore hota hai.

Connections

Animation — FuncAnimation — woh parent topic jiske liye yeh page tumhe prepare karta hai.
Matplotlib Figure and Axes — fig/ax canvas.
Artists in Matplotlib — Line2D, set_data, blitting.
Generators in Python — frames ke peeche yield machine.
Event Loops / GUI backends — woh timer jo har frame fire karta hai.
NumPy linspace and broadcasting — per-frame arrays banana.
Saving figures and ffmpeg — mp4/gif mein export karna.