` - args` and ` - kwargs` — flexible argument passing

1.2.29 · Coding › Introduction to Programming (Python)

YE CHEEZ EXIST KYU KARTI HAI?

* aur ** unpacking/packing operators hain. args aur kwargs naam sirf convention hain — asli cheez * aur ** hai.

YE HAIN KYA EXACTLY?

Toh * ke do kaam hain, side ke hisaab se:

Side	`*seq`	`**dict`
Definition (collect/pack)	extra positionals ko gather karo → tuple	extra keywords ko gather karo → dict
Call (spread/unpack)	list/tuple ko positionals mein spread karo	dict ko keyword args mein spread karo

KAISE KAAM KARTA HAI — First Principles se samjho

Sabse simple cheez se shuru karo aur badhate jao.

Step 1 — ek fixed function.

def add(a, b):
    return a + b
add(2, 3)   # 5

Ye step kyun? Baseline rigidity establish karta hai: exactly 2 args allowed.

Step 2 — Python ko extra values ek tuple mein pack karne do.

def add(*args):
    print(args)        # (2, 3, 4) — ek TUPLE
    total = 0
    for x in args:
        total += x
    return total
add(2, 3, 4)   # 9

Ye step kyun? * Python ko batata hai: "jo bhi extra positional values bachi hain, unhe ek tuple mein daal do jiska naam args ho." Ab function kisi bhi count ke liye kaam karta hai.

Step 3 — keyword leftovers ek dict mein jaate hain.

def describe(**kwargs):
    print(kwargs)      # {'name': 'Ravi', 'age': 20} — ek DICT
    for key, value in kwargs.items():
        print(f"{key} = {value}")
describe(name="Ravi", age=20)

Ye step kyun? ** un key=value pairs ko pakadta hai jinke liye koi named parameter match nahi karta, aur ek dictionary banata hai.

Step 4 — canonical full ordering.

def f(a, b, *args, **kwargs):
    ...

Definition mein legal order hamesha yeh hota hai: $positional \to *args \to keyword-only \to **kwargs$ Kyun? Python pehle named positionals satisfy karta hai, phir baaki positionals *args mein sweep karta hai, phir baaki keywords **kwargs mein sweep karta hai. **kwargs last hona chahiye kyunki iske baad kuch bhi nahi aa sakta — ye ek "catch-all dict" hai.

Figure — ` - args` and ` - kwargs` — flexible argument passing

Call-site unpacking (mirror image)

def add(a, b, c):
    return a + b + c
 
nums = [1, 2, 3]
add(*nums)            # same as add(1, 2, 3) -> 6
 
opts = {'a': 1, 'b': 2, 'c': 3}
add(**opts)           # same as add(a=1, b=2, c=3) -> 6

Worked Examples

Worked example Example 1 — ek flexible logger jo arguments forward karta hai

def log_call(func, *args, **kwargs):
    print("calling", func.__name__, "with", args, kwargs)
    return func(*args, **kwargs)
 
log_call(pow, 2, 3)          # args=(2,3)  -> 8
log_call(round, 3.14159, ndigits=2)   # kwargs={'ndigits':2} -> 3.14

Ye step kyun? log_call ko pata nahi func ko kya chahiye. *args, **kwargs se catch karke aur func(*args, **kwargs) se re-spread karke, ye kisi bhi function ko wrap kar sakta hai. Exactly aise hi decorators kaam karte hain.

Worked example Example 2 — kisi bhi number of inputs ka average

def mean(*nums):
    if not nums:                 # empty tuple guard
        return 0
    return sum(nums) / len(nums)
 
mean(10, 20, 30)   # 20.0
mean()             # 0   (nums is an empty tuple () )

Ye step kyun? Jab koi args nahi diye jaate, nums () hota hai, error nahi — isliye hum division by zero se bachne ke liye guard lagate hain.

Worked example Example 3 — unpacking se dicts merge karna

defaults = {'color': 'red', 'size': 'M'}
user     = {'size': 'L'}
final = {**defaults, **user}     # {'color':'red', 'size':'L'}

Ye step kyun? ** dono dicts ko ek literal mein unpack karta hai. Baad wali keys pehli wali ko override karti hain, toh size par user jeet jaata hai.

Forecast-then-Verify

Recall Aage padhne se pehle output predict karo

def f(a, *args, **kwargs):
    return a, args, kwargs
print(f(1, 2, 3, x=9))

::: a=1, phir args=(2, 3), phir kwargs={'x': 9}. Output: (1, (2, 3), {'x': 9}). a pehla positional leta hai, args baaki lata hai, x=9 ka koi named slot nahi toh woh kwargs mein jaata hai.

Common Mistakes (Steel-manned)

Recall Feynman: ek 12-saal ke bachhe ko samjhao

Ek teacher ka imagine karo jo homework collect kar raha hai. *args ek badi tray hai: "kitne bhi papers yahan phenk do, order mein, aur main unhe stack karke rakhunga." **kwargs ek labelled box hai: "agar tumhare paper par ek name tag hai jaise name=Ravi, isko is box mein daal do aur main yaad rakhunga ki kaun sa tag kaun se paper ke saath hai." Teacher (function) ko pehle se kabhi pata nahi kitne students aayenge — lekin tray aur labelled box koi bhi amount rakh sakte hain. Aur jab teacher woh pile doosre teacher ko deta hai, toh aage * lagaane ka matlab hai "in papers ko ek ek karke wapas spread karo."

Flashcards

*args arguments ko kis cheez mein collect karta hai?

Saare extra positional arguments ka ek tuple.

**kwargs arguments ko kis cheez mein collect karta hai?

Saare extra keyword arguments ka ek dict.

Kya args mutable hai?

Nahi — ye ek tuple hai (immutable).

Definition mein required parameter order kya hai?

positional, *args, keyword-only, **kwargs.

Call site par, f(*mylist) kya karta hai?

List ko alag-alag positional arguments mein unpack/spread karta hai.

Call site par, f(**mydict) kya karta hai?

Dict ko alag-alag keyword arguments mein unpack karta hai.

Definition mein **kwargs last kyun hona chahiye?

Ye ek catch-all dict hai; jab koi parameter baaki saare keywords absorb kar le toh uske baad kuch nahi aa sakta.

Agar def f(*nums) ho aur aap f() call karo, toh nums kya hoga?

Ek empty tuple ().

{**a, **b} conflicting keys par kya karta hai?

Dono dicts ko merge karta hai; b (baad wale) ki keys a wali keys ko override karti hain.

Kya args/kwargs naam Python ke liye required hain?

Nahi — sirf * aur ** matter karte hain; naam convention hain.

Decorators arbitrary arguments kaise forward karte hain?

*args, **kwargs se catch karke aur func(*args, **kwargs) se re-call karke.

Connections

Functions and Parameters — woh foundation jisko *args/**kwargs extend karte hain.
Default Arguments — catch-alls ke saath combine karo flexible signatures ke liye.
Tuples — *args jo produce karta hai.
Dictionaries — **kwargs jo produce karta hai.
Decorators — argument forwarding ke heavy users.
Unpacking Assignment — a, *rest = [1,2,3] mein bhi same star idea use hota hai.