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

1.2.29 · D1 · Coding › Introduction to Programming (Python) › [[1.2.29 - args and - kwargs — flexible argument passing| - args and - kwargs — flexible argument passing]]

Is sentence ko samajhne se pehle, tumhe usmein har word aur symbol par pakad banaani hogi. Yeh page unhe ek-ek karke build karta hai, bilkul zero se. Neeche kuch bhi assume nahi kiya gaya ki tum pichla topic pehle se jaante ho — hum har piece khud earn karte hain.

Atoms, build order mein

1. Ek value aur ek variable

Picture: shelf par ek labelled box ki imagine karo. Box value hold karta hai; label variable ka naam hai. Figure s01 mein naam tag x ko value 5 ki taraf point karte hue box ke andar dikhaya gaya hai — pink arrow ko tag se box tak trace karo.

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

Figure s01 — ek variable ek name tag hai jo ek box mein stored value ki taraf point karta hai.

Topic ko yeh kyun chahiye: *args aur **kwargs khud sirf variable names hain jo values ke ek bucket ki taraf point karte hain. Agar "name points at value" solid nahi hai, toh kuch bhi samajh nahi aayega.

2. Ek function — ek machine with input slots

Definition Function

Ek function ek reusable machine hai. Tum usse inputs dete ho, woh kuch steps run karta hai, aur ek output wapas deta hai. Python mein tum ise def se banate ho:

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

def add(a, b): ko is tarah padho: "Ek machine define karo jiska naam add hai aur jisme do input slots hain, a aur b." Word return ka matlab hai "yeh value use wapas do jo mujhe call kar raha hai."

Figure s02 ise literally draw karta hai: values 2 aur 3 (pink arrows) do slots a aur b mein enter karti hain, machine return a + b run karta hai, aur result 5 yellow arrow par nikalta hai.

Figure s02 — inputs named slots mein flow karte hain, machine compute karta hai, ek output bahar nikalta hai.

Parentheses ke andar slots a aur b ko parameters kehte hain (machine par names).
Jab tum actually ise run karte ho, add(2, 3), toh 2 aur 3 arguments hain (woh values jo tum feed karte ho).

Topic ko yeh kyun chahiye: *args/**kwargs ek special kind ka parameter hai. Tum flexible slot tab tak nahi samajh sakte jab tak fixed slot nahi samjha. Dekho Functions and Parameters.

3. Positional vs keyword arguments

Yeh distinction woh hinge hai jis par poora topic ghoomta hai.

Figure s03 dono ko contrast karta hai. Top row (positional) mein values apne order se slot hoti hain; bottom row (keyword) mein arrows cross karte hain kyunki b=3 pehle likha gaya hai lekin phir bhi slot b mein jaata hai.

Figure s03 — positional filling order par rely karti hai; keyword filling names par rely karti hai (arrows cross kar sakte hain).

Topic ko yeh kyun chahiye: *args positional leftovers pakadta hai; **kwargs keyword leftovers pakadta hai. Yeh do buckets isliye hain kyunki value pass karne ke do tarike hain. Yeh split miss karo toh poora topic arbitrary lagega.

Worked example Same call, do styles

add(2, 3)          # positional: order decide karta hai
add(a=2, b=3)      # keyword: names decide karte hain

Dono 5 dete hain. kwargs mein kw literally keyword ke liye stand karta hai.

4. Ek tuple — ek ordered, lock-shut list

Picture: numbered pigeonholes ki ek row, tape se seal ki hui. Tum pigeonhole 0, 1, 2… padhh sakte ho lekin tum unhe re-stuff nahi kar sakte.

Topic ko yeh kyun chahiye: parent note kehta hai "*args ek tuple hai." Yeh sentence empty hai jab tak tumhe pata na ho ki tuple kya hai aur usse kyun choose kiya gaya.

5. Ek dictionary — name → value pairs ka ek set

Picture: ek real dictionary book — tum "4th word" nahi poochte, tum "word apple" poochte ho aur uska meaning milta hai. Figure s04 mein har key box (name, age) ek arrow se apne value box ki taraf map karta hai — koi position numbers nahi, sirf names.

Figure s04 — ek dict cheezein naam se lookup karta hai: har key apni value tak map karti hai.

Topic ko yeh kyun chahiye: keyword arguments already name → value pairs ke roop mein aate hain (age=20). Name→value pairs ka perfect container ek dict hai — isliye **kwargs unhe ek dict mein collect karta hai. Dekho Dictionaries.

6. Star `*` aur double-star `**` symbols

Ab woh do symbols jinke naam par topic rakha gaya hai. Unka ek meaning hai jo do tarah se bola jaata hai: "unbundle / rebundle a group."

Worked example

* kisi bhi iterable ko spread karta hai, sirf lists ko nahi

def add3(a, b, c):
    return a + b + c
add3(*[1, 2, 3])      # list      -> 6
add3(*(1, 2, 3))      # tuple     -> 6
add3(*range(1, 4))    # range     -> 6
add3(*"abc")          # string -> add3('a','b','c')

Chaaron kaam karte hain kyunki har ek iterable hai. Koi conversion needed nahi.

Topic ko yeh kyun chahiye: literally woh do characters jinke baare mein chapter hai. Sabse common confusion (parent ke mistakes ke hisaab se) yeh hai ki bhool jaate hain ki direction def aur call ke beech flip hoti hai.

7. Iteration — ek group mein se ek item at a time walk karna

Picture: ek haath pigeonholes ki row mein slide karta hua, har ek par rukta hua.

Topic ko yeh kyun chahiye: ek baar jab *args ne values ko tuple mein bundle kar diya, tum almost always unpar loop karte ho (jaise unhe add karne ke liye). Dicts ke liye tum .items() par loop karte ho, jo tumhe har (key, value) pair deta hai.

8. Ek default value — ek slot with a fallback

Topic ko yeh kyun chahiye: defaults aur catch-alls cousins hain — dono function ki signature ko flexible banate hain. Woh parameter-ordering rules bhi share karte hain jinki topic ko care hai. Details Default Arguments mein.

9. Keyword-only parameters — slots jinhe tum zaroor name karo

Jis moment tum *args kisi signature mein dalte ho, ek brand-new kind ka slot uske baad appear hota hai.

Definition Keyword-only parameter

Ek keyword-only parameter koi bhi parameter hai jo *args ke baad likha ho (ya ek bare * ke baad). Kyunki *args pehle se saari leftover positional values nigar chuka hai, inhe reach karne ka koi positional tarika nahi bachta — isliye caller ko unhe naam se pass karna hi padega.

def greet(*names, greeting="Hi"):
    for n in names:
        print(greeting, n)
 
greet("Ravi", "Sara")                 # greeting "Hi" rahega
greet("Ravi", greeting="Hello")       # greeting=... zaroor use karo

Agar tumne greet("Ravi", "Hello") try kiya, toh "Hello" names mein join ho jaata, greeting mein nahi — positional kabhi bhi keyword-only slot tak nahi pahunch sakta.

Topic ko yeh kyun chahiye: keyword-only parameters ek alag lesson nahi hain — woh automatically *args ko signature mein place karne se fall out hote hain. Tum correctly signature order nahi kar sakte bina yeh jaane ki yeh slot exist karta hai.

10. Parameter-ordering rule — ek legal sequence

Tum ab har kind ka slot jaante ho. Woh sirf ek hi order mein appear ho sakte hain, aur Python isse enforce karta hai.

Formula Legal parameter order (left to right)

$positional-or-keyword \to defaulted \to *args \to keyword-only \to **kwargs$ Code mein:

def f(a, b=0, *args, kw_only, extra="x", **kwargs):
    ...

a — plain slot, position ya naam se fill karo.
b=0 — same, lekin default hai isliye omit kiya ja sakta hai.
*args — saari remaining positional values ko ek tuple mein sweep up karta hai.
kw_only, extra="x" — *args ke baad appear karte hain, isliye woh keyword-only hain.
**kwargs — saari remaining keyword values ko ek dict mein sweep up karta hai. Hamesha last.

Topic ko yeh kyun chahiye: yeh woh rule hai jis par parent note rely karta hai. Har valid def f(a, b, *args, **kwargs) aur har rejected permutation upar wale single sequence se explain hoti hai.

11. Forwarding — ek function doosre ko same inputs ke saath call karna

Picture: ek mail sorter jo ek sealed parcel receive karta hai aur, usse khole bina, use unchanged next mailbox mein drop kar deta hai.

Topic ko yeh kyun chahiye: yeh payoff hai. Ek wrapper jo *args, **kwargs se pakadta hai aur func(*args, **kwargs) re-call karta hai woh kisi bhi function ko wrap kar sakta hai — yahi woh mechanism hai jo Decorators ke peeche hai.

Foundations topic ko kaise feed karte hain

Ise top-down padho: values variables mein rehti hain, variables function slots fill karte hain, slots positional vs keyword mein split hote hain, har kind ko star operators ke through ek matched container milta hai, *args keyword-only slots paida karta hai, ordering rule poori signature lock karti hai, aur forwarding ise real-world payoff mein bandh karta hai.

Equipment checklist

Khud test karo — answer reveal karne se pehle zor se bolo.

Parameter aur argument mein kya difference hai?

Parameter = def mein named slot; argument = call par pass ki gayi actual value.

Ek positional argument apne slot se kya match karta hai?

Call mein uski position/order.

Ek keyword argument apne slot se kya match karta hai?

Uska naam, jaise age=20, isliye order matter karna band ho jaata hai.

Ek tuple kaunsi tarah ka container hai, aur kya tum ise change kar sakte ho?

Ek ordered collection; nahi — yeh immutable (locked) hai.

*args ke liye tuple (list nahi) sahi ghar kyun hai?

Extra positionals ka ek order hota hai aur unhe silently mutate nahi hona chahiye, isliye ek ordered, immutable container fit hai.

Ek dict kya hai aur tum usmein cheezein kaise lookup karte ho?

Key→value pairs ka ek collection; tum key/naam se lookup karte ho, position se nahi.

**kwargs ek dict kyun produce karta hai?

Keyword arguments already name→value pairs hote hain, jo exactly wahi hai jo ek dict store karta hai.

Ek definition mein * kya karta hai?

Bahut saari leftover positional values ko ek tuple mein pack karta hai.

Ek call mein *mylist kya karta hai?

List ko wapas separate positional arguments mein spread karta hai.

Kya call site par * kisi bhi iterable par kaam karta hai?

Haan — lists, tuples, ranges, strings, koi bhi iterable; koi conversion needed nahi.

def aur call ke beech * ki direction mein kya difference hai?

Def mein woh collect karta hai (many→one); call par woh spread karta hai (one→many).

Ek keyword-only parameter kya hai aur kab appear hota hai?

*args ke baad (ya ek bare * ke baad) rakha gaya parameter; ise sirf naam se pass kiya ja sakta hai.

Ek def mein ek legal parameter order kya hai?

positional-or-keyword → defaulted → *args → keyword-only → **kwargs.

def f(**kwargs, *args) SyntaxError kyun hai?

**kwargs saare remaining keywords absorb kar leta hai, isliye uske baad kuch nahi aa sakta; yeh last hona chahiye.

for key, value in d.items(): har pass mein kya deta hai?

Dict se ek (key, value) pair.

func(*args, **kwargs) ke saath forwarding ek wrapper ko kya karne deta hai?

Koi bhi received arguments seedhe through pass karna, taaki woh kisi bhi function ko wrap kar sake.

Connections

Yeh note Hinglish mein →
Functions and Parameters — woh machine-with-slots jise yeh foundations extend karte hain.
Default Arguments — function signatures ke liye doosra flexibility tool.
Tuples — woh container jo *args produce karta hai.
Dictionaries — woh container jo **kwargs produce karta hai.
Unpacking Assignment — wahi star idea a, *rest = [1, 2, 3] mein use hota hai.
Decorators — jahan forwarding pay off hota hai.