Visual walkthrough — Functions — def, parameters, return, docstrings

1.2.27 · D2 · Coding › Introduction to Programming (Python) › Functions — def, parameters, return, docstrings

Hum ek running example use karenge: ek machine jo do numbers add karti hai. Purposely simple rakha hai — plumbing hi lesson hai, arithmetic nahi.

Step 1 — Raw, repeated work se shuru karo

KYA HAI. Functions exist karne se pehle, maan lo aap baar baar same computation likhte rehte ho. Maan lo aapko apne program mein teen alag jagah do numbers ka sum chahiye.

KYUN. Hume us dard ko feel karna hai jo functions theek karte hain. Dard hai repetition — a + b baar baar likhna, har copy mein ek jagah bug chhup sakta hai. Yeh exactly woh DRY Principle ("Don't Repeat Yourself") hai jiska parent note ne naam liya tha.

PICTURE. Ek hi chhoti si calculation ki teen alag copies, jo time ke saath alag hoti jaati hain.

Teen orange blocks dekho: identical logic, teen chances typo karne ke, aur teen edits jab bhi formula badlega. Hum chahte hain ek block jis par sab point karein.

Step 2 — def machine banata hai lekin use run NAHI karta

KYA HAI. Hum logic ko ek baar wrap karte hain aur use ek naam dete hain.

def add(a, b):
    return a + b

KYUN. Keyword def (short for define) Python ko batata hai: "is block ko add naam ki machine ki tarah store karo — abhi execute mat karo." Yeh sabse zyada galat samjha jaane wala point hai: defining ≠ running. Definition ke time Python sirf machine banata hai aur us par ek name-tag lagata hai.

Pehli line def add(a, b): ko term by term dekho:

• def — woh keyword jo kehta hai "yahan ek machine definition shuru hoti hai."
• add — woh name (name-tag) jo baad mein call karne ke liye use karoge.
• (a, b) — do parameters: khali slots jo fill hone ka wait kar rahe hain.
• : — indented body shuru karta hai (andar ke hidden inner workings).

PICTURE. Ek boxed machine shelf par rakhi hai, add label lagi hai, do khali input slots hain aur ek output chute hai. Abhi tak kuch bhi us se guzra nahi.

Slots a aur b hollow hain — jab tak koi machine ko call nahi karta, inme koi value nahi hoti.

Step 3 — Calling slots ko fill karta hai (parameters ← arguments)

KYA HAI. Hum machine ko real values ke saath call karte hain:

add(2, 3)

KYUN. Sirf definition se kuch compute nahi hota. Parentheses () "button dabao" wala action hai. Andar ki values — 2 aur 3 — arguments hain: woh actual coins jo aap slots mein daalo. Python inhe position ke hisaab se parameters se bind karta hai:

$\underset{\text{argument}}{\underbrace{2}}\to \underset{\text{parameter (slot)}}{\underbrace{a}}\underset{\text{argument}}{\underbrace{3}}\to \underset{\text{parameter (slot)}}{\underbrace{b}}$

• Argument woh value hai (arrow ke right side) — jo aapke paas hai.
• Parameter woh slot name hai (left side) — jahan woh land karta hai.
• Arrow woh binding hai: is ek call ki duration ke liye, machine ke andar a ka matlab 2 hai aur b ka matlab 3 hai.

PICTURE. 2 aur 3 label wale do coins a aur b label wale slots mein girate hain. Slots ab light up ho jaate hain kyunki unme kuch hai.

Step 4 — Body run hoti hai, return answer bahar bhejta hai

KYA HAI. Andar, a = 2 aur b = 3 ke saath, Python body run karta hai aur return a + b tak pahunchta hai.

KYUN. Body kaam karti hai, lekin machine ke andar kiya gaya kaam andar hi band rehta hai jab tak hum use wapas na dein. return ek saath do kaam karta hai:

1. Yeh value a + b = 5 ko compute karke chute se bahar bhejta hai jisne call kiya usse.
2. Yeh machine ko turant exit karta hai — us path par return ke baad kuch bhi nahi chalta.

$\text{return}\underset{2}{\underbrace{a}}+\underset{3}{\underbrace{b}}⟶\text{call }\text{add(2, 3)}\text{ ab }5\text{ ke barabar hai}$

Poora expression add(2, 3) ban jaata hai 5 — jaise aapne wahan 5 type kiya ho.

PICTURE. Value 5 chute se bahar aati hai; machine ke andar ke slots phir se dark ho jaate hain (call khatam, a aur b bhula diye gaye).

Step 5 — Output ko pakadna vs use floor par girne dena

KYA HAI. Hum usually returned value ko ek variable mein pakad lete hain:

result = add(2, 3)   # result ab 5 hai

KYUN. Call evaluate hoti hai 5 par; = assignment us 5 ko result naam se store kar leta hai. Agar aap use assign nahi karte aur use nahi karte, toh 5 simply floor par gir jaata hai aur kho jaata hai.

PICTURE. Chute se aaya 5 ek labelled cup result mein pakda jaata hai. Saath mein, ek un-caught 5 zameen par girta hai — compute hua, phir waste ho gaya.

Step 6 — Degenerate case: koi return nahi → None

KYA HAI. Agar machine mein koi return na ho (ya sirf print ho) toh kya?

def show(a, b):
    print(a + b)      # display karta hai, wapas NAHI bhejta

KYUN. print ek lamp jalata hai insaan ke liye screen padhne ke liye — yeh chute se kuch nahi bhejta. Toh x = show(2, 3) pehle screen par 5 dikhata hai, lekin chute special empty value ==None== deliver karta hai. Yeh parent note ka print ≠ return trap hai, physically dekha gaya: lamp chute nahi hai.

$x=\text{show(2, 3)}\Rightarrow \text{screen par }5\text{ dikhta hai},x=\text{None}$

PICTURE. Machine ke upar lamp 5 glow karta hai (aapki aankhon ke liye), jabki output chute cup mein ek hollow None token deliver karta hai.

Step 7 — Ek saath do cheezein return karna (ek tuple)

KYA HAI. Ek machine kai values wapas de sakti hai unhe comma se separate karke:

def divmod2(a, b):
    """Return (quotient, remainder)."""
    return a // b, a % b
 
q, r = divmod2(17, 5)   # q = 3, r = 2

KYUN. return a // b, a % b dono results ko ek single package mein pack karta hai — ek tuple (3, 2) (dekho Lists and Tuples). Ek call, ek chute, lekin package mein do items hain. Left side par, q, r = ... package ko unpack karta hai, har item ko uski apni cup mein dalta hai.

• a // b — integer division: 17 mein kitne poore 5 aate hain → 3.
• a % b — remainder: kya bacha → 2.
• inke beech comma — woh packing jo ise tuple banati hai.

PICTURE. Ek chute ek bundle (3, 2) deliver karta hai; bundle do cups q aur r mein split ho jaata hai.

Step 8 — Docstring: machine par ek sticker

KYA HAI. def ke neeche pehla string literal docstring hota hai:

def add(a, b):
    """Return the sum of a and b."""
    return a + b

KYUN. Chhe mahine baad, "add kya karta hai?" ka jawab help(add) se turant milta hai. Docstring documentation hai jo machine ke andar hi travel karti hai — box par chipka hua sticker, koi alag kaagaz par note nahi jo kho jaaye.

PICTURE. Finished machine jiske front par ek sticker laga hai jisme likha hai "Return the sum of a and b."

Ek-picture summary

Ek diagram mein har idea: arguments parameter slots mein girate hain → body run hoti hai → return ek value (ya tuple) chute se bahar bhejta hai → caller use pakad leta hai, ya None milta hai agar koi return nahi tha.

Connections

• Variables and Scope — bhari hue slots a, b sirf machine ke private scope mein rehti hain.
• Control Flow — if statements — body alag returns par branch kar sakti hai.
• Lists and Tuples — Step 7 ka multi-return tuple packing/unpacking hai.
• Recursion — ek machine jiskii body khud ko call karti hai.
• Lambda and Higher-order Functions — same slot/chute idea, ek line, koi naam nahi.
• DRY Principle — Step 1 ka dard exactly wahi hai jo yeh poora picture theek karta hai.