Default parameters, keyword arguments: Worked examples

1.2.28 · D3 · Coding › Introduction to Programming (Python) › Default parameters, keyword arguments

Scenario matrix

Ek function call ko socho jaise slots bhar rahe ho left se right, kuch slots mein defaults pehle se loaded hain. Jo cheezein vary ho sakti hain woh hain: tum slots kaise bharte ho, kya beech ka koi slot skip karte ho, aur "empty" input ka matlab kya hai. Isse yeh case classes milti hain:

Cell	Case class	Kya tricky hai	Worked in
C1	Sab positional, koi default touch nahi	baseline — kuch special nahi	Ex 1
C2	Ek default omit karo (factory value use karo)	fallback fire hona prove karo	Ex 2
C3	Ek default ko positionally override karo	order matters	Ex 3
C4	Beech ka default skip karo, baad wale ko keyword se set karo	keywords kyun exist karte hain	Ex 4
C5	Positional phir keyword mix karo (Rule 2 boundary)	legal vs `TypeError`	Ex 5
C6	Illegal orderings (dono rules tode)	actual errors dekho	Ex 6
C7	Degenerate input: `None` vs empty `[]` vs `0`/`""`	falsy aur missing same nahi hote	Ex 7
C8	Mutable-default trap + fix (state leaking across calls)	woh famous bug, call-by-call trace kiya	Ex 8
C9	Real-world word problem (pizza order builder)	English → call translate karo	Ex 9
C10	Exam twist: default ek baar evaluate hota hai, def-time pe	definition ke waqt ek global read	Ex 10

Figure — Default parameters, keyword arguments

Upar ki picture is poore page ke liye hamara mental model hai: definition mein slots ki ek row, kuch pre-loaded (teal) defaults ke saath, aur ek call jo har value ko ek slot mein route karti hai ya toh position se (orange arrow, left-to-right) ya name se (plum arrow, labeled slot pe seedha jump). Ise dhyan mein rakho — neeche har example bas ek alag routing hai.

Example 1 — C1: baseline, sab positional

Steps

Python ke paas do slots hain: width, phir height. Yeh step kyun? Slots left se right position se bhare jaate hain — yeh woh default matching rule hai jiske upar baaki sab build hota hai.
4 width mein jaata hai, 3 height mein jaata hai.
Return 4 * 3 = 12.

Verify: ek 4-by-3 rectangle ka area $4 \times 3 = 12$ hai. Units: (length)×(length) = area. ✓

Example 2 — C2: ek default omit karo, factory value fire hota hai

Worked example Statement

def greet(name, greeting="Hello"):
    return greeting + ", " + name
greet("Asha")

Forecast: humne sirf EK value di lekin function ko do cheezein chahiye — doosri kahan se aati hai?

Steps

name position se "Asha" se bhara jaata hai. Yeh step kyun? Yeh pehla (non-default) slot hai, isliye pehla argument yahan jaata hai.
greeting supply nahi kiya gaya. Python definition dekhta hai aur greeting="Hello" paata hai. Yeh step kyun? Ek missing default parameter def line mein baki value pe fall back karta hai — default ka poora point yahi hai.
Return "Hello" + ", " + "Asha" = "Hello, Asha".

Verify: output string exactly Hello, Asha hai. ✓

Example 3 — C3: ek default ko positionally override karo

Steps

Pehla slot name ← "Asha" (position 1). Yeh step kyun? Left-to-right filling defaults se affect nahi hoti; default bas yeh kehta hai kya use karo agar kuch na aaye.
Doosra slot greeting ← "Namaste" (position 2). Yeh default "Hello" ko override karta hai. Yeh step kyun? Ek supplied positional argument hamesha fallback se jeetta hai.
Return "Namaste, Asha".

Verify: output Namaste, Asha hai — greeting override hui, name untouched. ✓

Example 4 — C4: beech ka default skip karo, baad wala naam se set karo

Yeh woh cell hai jo justify karti hai ki keyword arguments exist kyun karte hain (dekho DRY principle - Don't Repeat Yourself — hum woh values dobara type karne se refuse karte hain jinki humhe parwah nahi).

Worked example Statement

def power(base, exp=2, mod=None):
    r = base ** exp
    return r if mod is None else r % mod
power(5, mod=7)

Forecast: humne kabhi exp mention nahi kiya. Woh kya banega, aur final number kya hai?

Steps

base ← 5 by position. Yeh step kyun? pehla required slot.
exp skip kiya gaya. Hum mod tak positionally nahi pahunch sakte exp ke liye kuch pass kiye bina — isliye hum seedha mod pe naam se jump karte hain. Yeh step kyun? Ek keyword argument label se route karta hai, isliye woh untouched middle slot ko hop over kar leta hai. Positionally yeh impossible hai; wahi impossibility exactly woh reason hai jiske liye keywords banaye gaye.
exp isliye apna default 2 rakhta hai; mod ← 7.
Compute r = 5 ** 2 = 25, phir kyunki mod None nahi hai, return karo 25 % 7.
$25 = 3 \times 7 + 4$ , isliye 25 % 7 = 4.

Verify: $5^{2} = 25$ , aur $25 mod 7 = 4$ kyunki $7 \times 3 = 21$ , remainder $4$ . ✓

Figure mein plum keyword arrow teal exp slot ke upar ude jaata hai (jo quietly apna default 2 pakde hota hai) aur mod pe land karta hai. Woh leap hi superpower hai.

Example 5 — C5: legal mix (positional phir keyword)

Steps

width ← 2, height ← 5 by position. Yeh step kyun? Sab positional arguments pehle resolve hote hain, left to right.
x kabhi naam liya gaya na height ke baad position kiya gaya, isliye woh apna default 0 rakhta hai. Yeh step kyun? Untouched default → fallback.
y=1 keyword se apna default 0 override karta hai.
Result tuple (2, 5, 0, 1).

Verify: (width, height, x, y) == (2, 5, 0, 1). ✓ Note karo 2, 5 keyword y=1 se pehle aaye — Rule 2 satisfied.

Example 6 — C6: illegal orderings (actual errors dekho)

Worked example Statement — teen broken snippets

# (a) definition: default before non-default
def f(a=1, b): ...
# (b) call: keyword before positional
box(width=2, 5)
# (c) call: same argument twice
greet("Asha", name="Asha")

Forecast: kaun sa error har ek raise karta hai — same wala, ya teen alag?

Steps

(a) Python def line padhta hai aur ek non-default (b) baad mein ek default (a=1) ke dekhta hai. Yeh kyun fail hota hai: agar baad mein kisi call ne ek bare positional pass kiya, Python nahi bata sakta ki woh a bharta hai ya b. Ambiguity khatam karne ke liye, yeh ek SyntaxError: non-default argument follows default argument hai — function exist hone se pehle hi pakda jaata hai.
(b) Call mein, jab width=2 dekha jaata hai, ek following bare 5 ke liye koi slot nahi hai jis par Python trust kar sake. Yeh kyun fail hota hai: positionals pehle resolve hone chahiye (Rule 2). → SyntaxError: positional argument follows keyword argument.
(c) "Asha" (position 1) ne pehle hi name fill kar diya; phir name="Asha" use dobara fill karne ki koshish karta hai. Yeh kyun fail hota hai: ek slot, do values. → TypeError: greet() got multiple values for argument 'name'.

Verify: teen alag errors — do SyntaxErrors (parse/def time pe pakde gaye) aur ek TypeError (call time pe pakda gaya). Distinction matter karta hai: syntax errors file ko load hone se rokते hain. ✓

Example 7 — C7: degenerate inputs (`None` vs `0` vs `""` vs `[]`)

Worked example Statement

def show(value, label=None):
    label = label if label is not None else "value"
    return f"{label}={value}"
show(0)
show("", label="")

Forecast: kya show(0) 0 ko "missing" treat karta hai? Kya label="" "value" se replace ho jaata hai?

Steps

show(0): value ← 0. label pass nahi kiya → woh None hai → guard use "value" se replace kar deta hai. Yeh step kyun? Hum is None se test karte hain, jo poochta hai "kya yeh chhoot gaya?" — nahi "kya yeh falsy hai?". Isliye value mein 0 ek perfectly real value hai, rahi rehti hai.
Result: "value=0".
show("", label=""): label explicitly "" ke roop mein pass kiya gaya. "" is None False hai. Yeh step kyun? Caller ne deliberately empty string choose ki; is None correctly ise akela chodh deta hai (jabki ek sloppy if not label ise galat tarike se overwrite kar deta).
Result: "=" — yaani "={value}" dono empty ke saath → string "=".

Verify: show(0) == "value=0" aur show("", label="") == "=". ✓ Sabak (dekho Mutable vs immutable objects jisme identity is equality == se kyun differ karti hai): "missing" ek alag state hai "falsy" se; sirf is None inhe distinguish karta hai.

Example 8 — C8: mutable-default trap, call by call trace kiya

Steps

Jab def line ek baar runs karta hai, Python default list [] usi waqt build karta hai aur use function object ke andar store karta hai. Yeh step kyun? Defaults definition time pe evaluate hote hain, har call pe nahi — yeh single fact hi poora bug hai.
add(1): koi bag pass nahi kiya → shared stored list use hoti hai; append 1 → [1].
add(2): same stored list (abhi bhi [1]) → append 2 → [1, 2].
add(3): same list phir → [1, 2, 3].

Verify: outputs hain [1], [1, 2], [1, 2, 3] — nahi teen independent lists. ✓ Surprise confirmed.

Fix (None sentinel):

def add(item, bag=None):
    if bag is None:
        bag = []      # fresh list built INSIDE, every call
    bag.append(item)
    return bag

Ab add(1) → [1], add(2) → [2], add(3) → [3].

Verify (fixed): teen outputs hain [1], [2], [3], independent. ✓

Left panel: ek shared bag teen calls mein bharta ja raha hai (bug). Right panel: teen fresh bags, ek per call (fix). Pizza-topping-bowl metaphor jaisi hi shape parent note se. Related idea: Variable scope - local vs global — shared list function object ke saath rehti hai, har call ke local scope se zyada jeeti hai.

Example 9 — C9: real-world word problem (pizza order builder)

Worked example Statement

"Shop assume karta hai medium pizza with cheese aur koi extra toppings nahi jab tak koi kuch na kahe. Ek customer large with mushroom order karta hai, default cheese rakhte hue." Call aur uska result likho.

def order(base="cheese", size="medium", toppings=None):
    toppings = [] if toppings is None else toppings
    return f"{size} {base} pizza + {toppings}"
order(size="large", toppings=["mushroom"])

Forecast: teen knobs mein se humne actually kaun se touch kiye, aur string kya kehti hai?

Steps

base untouched → default "cheese". Yeh step kyun? customer ne cheese rakhi; ise omit karo, fallback fire hone do.
size="large" keyword se "medium" ko override karta hai. Keyword se kyun? Self-documenting hai — reader instantly dekh sakta hai kaun sa knob badla (parent note ka "80/20" idea: sirf unusual cheez badlo).
toppings=["mushroom"] — ek real list pass ki, isliye is None guard ise chodh deta hai. Guard kyun? C8 trap avoid karne ke liye; har order ko apni topping list milti hai.
Result: "large cheese pizza + ['mushroom']".

Verify: output equals large cheese pizza + ['mushroom']. ✓ Do knobs naam se badle, ek default raha — exactly woh convenient common-case-plus-override pattern.

Example 10 — C10: exam twist — default EK BAAR evaluate hota hai, def-time pe

Worked example Statement

LIMIT = 10
def cap(x, ceiling=LIMIT):
    return min(x, ceiling)
print(cap(50))     # (i)
LIMIT = 3          # def ke BAAD global change kiya
print(cap(50))     # (ii)

Forecast: jab hum LIMIT ko 3 kar dete hain, kya call (ii) 3 pe cap karta hai ya phir bhi 10 pe?

Steps

Jab def cap runs karta hai, Python ceiling=LIMIT ko usi waqt evaluate karta hai. Us instant mein LIMIT 10 hai, isliye default value 10 ke roop mein freeze ho jaata hai. Yeh step kyun? Defaults definition time pe value capture karte hain, variable name ka koi live link nahi hota.
cap(50) (i): ceiling default 10 se → min(50, 10) = 10.
Hum LIMIT = 3 reassign karte hain. Lekin default ne pehle hi 10 store kar liya — woh LIMIT dobara nahi padhta.
cap(50) (ii): ceiling abhi bhi 10 hai → min(50, 10) = 10 phir se.

Verify: dono calls 10 return karti hain; baad mein LIMIT badlane ka frozen default pe koi effect nahi. ✓ Yeh wahi "def-time pe ek baar evaluate" wali law hai jo C8 mutable trap cause karti hai — ek law, do consequences.

Recall Ek law do famous surprises explain karta hai

Def-time pe evaluate hona BOTH mutable-list trap (Ex 8) AND frozen-global twist (Ex 10) explain karta hai. ::: Haan — default expression exactly ek baar run hota hai jab def execute hota hai, woh value hamesha ke liye capture ho jaati hai.

Connections

Parent: Hinglish version
Functions - def and return
Variable scope - local vs global
*args and **kwargs (variadic functions)
Mutable vs immutable objects
DRY principle - Don't Repeat Yourself