Functions — def, parameters, return, docstrings: Question bank

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

Shuru karne se pehle, teen words jinhe hum baar baar use karenge — plain language mein define kiye gaye hain taaki kuch bhi assume na ho:

True ya false — justify karo

Har answer explain karta hai kyun, kyunki ek seedha "true/false" kuch nahi sikhata.

Defining a function with def also runs its body once.

False. def sirf function object banata hai aur naam bind karta hai; body tab hi run hoti hai jab tum use parentheses ke saath call karo — dekho Variables and Scope iske liye ki body ke names tab tak exist hi nahi karte.

print(x) aur return x ek hi kaam karte hain kyunki dono x ko dikhate hain.

False. print text ko screen pe ek human ke liye bhejta hai aur function tab bhi None return karta hai; return value ko program ko wapas deta hai taaki baad ka code use kar sake. Sirf ek hi y = f() mein usable hai.

Ek valid Python function mein return statement hona zaroori hai.

False. Bina return ka function bilkul valid hai; wo bas automatically None return karta hai. Bahut saare useful functions (jo sirf print karte hain ya list modify karte hain) kabhi return nahi karte.

return a, b do alag alag values return karta hai.

False. Ye sirf ek object return karta hai — ek tuple (a, b) — jise tum x, y = f() se unpack karte ho. Dekho Lists and Tuples tuple packing ke liye.

greet aur greet() ek hi cheez hain.

False. greet function object khud hai (machine shelf pe rakhi hai); greet() use call karta hai (button dabata hai). greet ko () ke bina pass karna wahi hai jo Lambda and Higher-order Functions functions ko around pass karne mein karte hain.

def add(a, b) mein a aur b arguments hain.

False. Ye parameters hain — khali slots. Arguments wo real values hain (jaise 2 aur 3) jo tum call ke time supply karte ho.

Ek hi file mein ek jaise naam ke do functions dono usable rehte hain.

False. Doosra def naam ko rebind kar deta hai, pehle wale ko silently replace kar deta hai — pehla unreachable ho jaata hai. Names sirf labels hain, aur ek label ek hi cheez ko point karta hai.

def f(exp=2, base): ek legal header hai.

False. Default wala parameter kabhi bhi bina default wale parameter se pehle nahi aa sakta; Python ek SyntaxError raise karta hai. Required slots pehle aane chahiye.

Docstring likhne se function ka return value badal jaata hai.

False. Ek docstring sirf function pe stored documentation hai; iska return value pe zero effect hota hai. Ye help() se padhne layak hai aur kabhi behaviour nahi badalta.

Error dhundho

Batao kya galat hai aur kaise tum mislead feel karte.

def square(n):
    print(n * n)
y = square(5)

y kyun 25 nahi hai?

square print use karta hai, return nahi, isliye wo 25 display karta hai lekin kuch wapas nahi deta — y None ban jaata hai. Screen output dekh ke lagta hai kaam ho gaya, yahi trap hai.

def add(a, b):
    return a + b
    print("done")

"done" kabhi kyun nahi dikhta?

return function se turant bahar nikal deta hai, isliye us path ke baad ka koi bhi code dead hai. Woh line silently unreachable hai.

def collect(item, bag=[]):
    bag.append(item)
    return bag

bag purani items ko calls ke across kyun yaad rakhta hai?

Default [] definition ke time ek baar create hota hai aur har us call ke saath share hota hai jo bag omit karta hai, isliye wo accumulate karta rehta hai. Fix hai ek None sentinel: default None karo, phir andar bag = [] set karo.

def greet(name):
    """Greet someone."""
greet("Sam")

Ye call kya wapas deta hai, aur kya ye bug hai?

Ye None return karta hai (koi return nahi), jo theek hai agar tum sirf side effect chahte the — lekin yahan koi print bhi nahi hai, isliye ye literally kuch bhi visible nahi karta. Khali body asli problem hai.

def power(base, exp=2)
    return base ** exp

Syntax ki galti dhundho.

Header mein colon : missing hai. Python ko def power(base, exp=2): chahiye taaki pata chale header khatam hua aur block shuru hota hai.

def f():
    x = 10
print(x)

print(x) kyun fail karta hai?

x sirf f ke apne scope mein rehta hai; bahar exist nahi karta. Ye hai Variables and Scope — locals isolated hote hain, bahar NameError deta hai.

def divide(a, b):
    return a / b
q, r = divide(17, 5)

Unpacking kyun fail hoti hai?

divide ek single float return karta hai, do values nahi, isliye q, r = ... use ek pair mein split nahi kar sakta. Tumhe return a // b, a % b chahiye hoga ek unpackable tuple ke liye.

Why questions

Kya se aage kyun aisa design hai tak jaao.

Functions exist kyun karte hain agar tum code copy-paste kar sakte ho?

DRY Principle follow karne ke liye — logic ek baar likho taaki fix ek jagah ho. Copy-paste matlab 12 jagah formula change karo aur ek miss kar do.

return value bhejna aur function rokna dono ek saath kyun karta hai, alag alag kyun nahi?

Kyunki ek baar answer ready ho jaata hai, continue karna waste hoga ya use overwrite kar dega. Rokna guarantee karta hai ki exactly ek answer har path se bahar aaye — ye Control Flow — if statements ke andar early exits ko bhi power karta hai.

"Parameter" aur "argument" mein fark kyun karte hain agar dono ek hi cheez hold karte hain?

Ye do alag moments describe karte hain: parameter wo khali slot hai jo definition pe fix hota hai, argument wo filling hai jo har call pe supply hoti hai. Ek definition, infinitely many argument sets.

Tum function ko keyword se (power(exp=3, base=2)) position ki jagah call kyun kar sakte ho?

Keywords values ko naam se bind karte hain, isliye order matter karna band ho jaata hai aur call khud ko document karta hai. Ye bahut saare parameters wale functions ke liye ek readability tool hai.

Docstring function ke andar rakha kyun jaata hai, uske upar comment ki jagah nahi?

Kyunki Python pehli string literal ko function ki official documentation ke roop mein store karta hai, runtime pe help() se retrieve karne layak. Ek # comment help() ko invisible hota hai.

Bare return (kuch bhi baad mein nahi) ka exist karna kyun zaroori hai?

Value produce kiye bina early exit karne ke liye — ek if ke andar bail out karne ke liye useful. Ye tab bhi None return karta hai, bas jaldi.

Khud ko call karne wala function (Recursion) possible kyun hai?

Kyunki def sirf ek naam bind karta hai; jab tak body run hoti hai (call ke time) wo naam already function ko point kar raha hota hai, isliye wo khud ko reference kar sakta hai.

Edge cases

Boundary aur degenerate situations jo logon ko surprise karti hain.

Khali body wala function (def f(): pass) kya return karta hai?

None. Koi return nahi matlab automatic "nothing" object wapas aata hai, chahe andar kuch hua hi nahi.

Agar f None return kare toh x, y = f() kya karta hai?

Ye TypeError raise karta hai — None ko do names mein unpack nahi kiya ja sakta. Ye return bhoolne ka common downstream symptom hai.

Agar function mein return ek if ke andar hai lekin condition false hai, toh kya wapas aata hai?

None, kyunki wo path body ke end tak pahunchta hai bina return hit kiye. Har path deliberately return karna chahiye, warna surprise Nones milte hain.

Kya tum file mein def line aane se pehle function call kar sakte ho?

Module top level pe nahi — naam tab tak bind nahi hota jab tak def execute na ho. Lekin doosre function ki body ke andar call theek hai, kyunki wo body baad mein run hoti hai, sab defs ke run ho jaane ke baad.

Agar tum parameters se zyada arguments pass karo toh kya hota hai?

TypeError — Python slots count karta hai aur mismatch refuse karta hai. Extra flexibility ke liye *args chahiye, jo is core se bahar hai.

Kya return a, b, c parentheses ke bina bhi tuple banata hai?

Haan — tuple commas se banta hai, brackets se nahi. (a, b, c) aur a, b, c yahan same object hain (dekho Lists and Tuples).

Agar do parameters ke defaults hain aur tum sirf ek positional argument supply karo, toh kaunsa slot fill hota hai?

Pehla parameter, position se; baaki apne defaults pe fall back karte hain. Position hamesha left-to-right fill karta hai defaults ke kaam aane se pehle.

Recall One-line self-check

Ek function jo sirf print karta hai aur kabhi return nahi karta — uska return value kya hai? ::: None, hamesha.

Connections

Variables and Scope — kyun function ke locals bahar gayab ho jaate hain.
Control Flow — if statements — jahan se early returns aur surprise Nones aate hain.
Lists and Tuples — return a, b ke peeche ka tuple.
Recursion — kyun function khud ko naam de sakta hai.
Lambda and Higher-order Functions — greet ko () ke bina pass karna.
DRY Principle — functions exist kyun karte hain.