Visual walkthrough — global and nonlocal keywords

1.2.31 · D2 · Coding › Introduction to Programming (Python) › global and nonlocal keywords

Hum poore walkthrough mein teen simple words use karenge. Unhe use karne se pehle main define karta hoon:

Reading = rooms mein jhankna koi note dhundhne ke liye. Assigning (name = ...) = kisi jagah note chipkana. Poori mystery yeh hai: note kis room mein chipakta hai?

Step 1 — Kisi Name Ko Touch Karne Ke Do Tarike

KYA HAI. Ek name ke saath tum exactly do cheezein kar sakte ho: use read karo (uski value use karo) ya use bind karo (name = left side pe likho, ya n += 1, for name in ..., def name, import name). Yeh dono actions bilkul alag rules follow karti hain.

YAHAN SE KYU SHURU KAREIN. Agar tum "reading" aur "binding" ko alag nahi karte, toh baad ke saare rules contradictory lagte hain. Reading aur binding do darwaaze hain — aur woh alag alag rooms mein khulete hain.

PICTURE. Neeche, green arrow (reading) ek existing note dhundhne ke liye baahir ki taraf travel karta hai. Magenta arrow (binding) ek note create karta hai aur — by default — use current room mein daal deta hai.

Step 2 — READING Ke Liye Scope Ladder (LEGB)

KYA HAI. Jab Python koi name read karta hai toh woh rooms ki ek ladder pe nearest room se shuru karke climb karta hai, aur pehle note pe rukh jaata hai. Rungs hain Local → Enclosing → Global → Built-in, yaani LEGB.

YEH ORDER KYU. Nearest room jeetta hai taaki ek inner function kisi outer name ko apne se "override" kar sake. Agar kisi bhi rung pe kuch nahi milta, toh NameError aata hai. Dekho Scope and LEGB rule.

PICTURE. Chaar nested rooms. Read-arrow innermost (Local) room se enter karta hai aur tab tak climb karta hai jab tak woh chahta hua note na dhundh le.

Step 3 — Woh Rule Jo SAARI Musibat Paida Karta Hai

KYA HAI. Binding ke liye, Python ladder nahi chadhta. Iske bajaaye woh ek blunt decision leta hai, ek baar, compile time pe (run hone se pehle):

Agar koi name function body mein kahiin bhi bind hota hai, toh woh name poore function ke liye local hai — uski har ek line mein.

YEH BLUNT KYU HAI. Python poore function ko pehle scan karta hai, ek count = ... kahin dekhta hai, aur count ko "is room ka hai" stamp kar deta hai poore function ke liye — assignment se upar wali lines ke liye bhi.

PICTURE. Scanner (magenta magnifying glass) poori function body sweep karta hai, ek binding spot karta hai, aur name ko LOCAL stamp kar deta hai har ek line ke liye — earlier read ke liye bhi.

Step 4 — Dekho Isko Crash Hote (Degenerate Case)

KYA HAI. Ab woh famous crash. count globally exist karta hai, lekin bump ke andar hum likhte hain count = count + 1.

count = 0
def bump():
    count = count + 1   # boom
bump()

YEH CRASH KYU KARTA HAI. Step 3 ne count ko bump ke liye poori tarah LOCAL stamp kar diya. Toh right side pe, count + 1 local count ko read karta hai — jisme abhi koi note chipka nahi hai. Result: UnboundLocalError (dekho UnboundLocalError). Global count = 0 wahin hai lekin Python dekhne se mana kar deta hai — ladder off hai.

PICTURE. Local room mein count label wala ek empty slot hai (reserved lekin khaali). Read uss empty slot se takraata hai aur ruk jaata hai — use global count = 0 tak chadhne ki izaazat nahi hai.

Step 5 — global: Local Stamp OFF Karo (Ground Floor Tak Pahuncho)

KYA HAI. global count compiler ko batata hai: "count ko local mat stamp karo. Yahan har count IS module-level wala hai, aur mere assignments usi ko rebind karte hain."

count = 0
def bump():
    global count
    count = count + 1
bump(); bump()
print(count)   # 2

YEH FIX KYU KARTA HAI. Local stamp hat jaane ke baad, right pe count global note read karta hai (value 0, phir 1), aur left pe count = naya note global slot pe wapas chipka deta hai. Counter calls ke baad survive karta hai kyunki global room function se zyada time tak rehta hai.

PICTURE. Function room se seedha Global (ground-floor) room tak ek tunnel. Read aur bind dono ab is tunnel se travel karte hain; local room khaali rehta hai.

Step 6 — nonlocal: Exactly EK Room Baahir Pahuncho (Agle Room Mein)

KYA HAI. Nested functions ke liye, woh variable jo tum chahte ho woh module mein nahi balki enclosing function mein rehta hai. nonlocal n nearest enclosing function ke note se bind karta hai — na local, na global. Yehi ek closure ko yaad rakhne* ki taakat deta hai.

def make_counter():
    n = 0
    def step():
        nonlocal n
        n += 1
        return n
    return step
 
c = make_counter()
print(c(), c(), c())   # 1 2 3

YAHAN global KYU NAHI. n make_counter (ek Enclosing room) mein rehta hai, module ground floor pe nahi. global n ek top-level n dhundhta aur kuch na paata. nonlocal exactly E rung tak pahunchta hai.

PICTURE. Teen rooms: module (ground) sabse neeche, beech mein make_counter, upar step. nonlocal arrow step se make_counter ke n tak neeche jaata hai — aur wahiin ruk jaata hai, module ko kabhi nahi choota.

Step 7 — Woh Case Jahan DONO Ki Zaroorat Nahi (Mutate ≠ Rebind)

KYA HAI. Reading, aur kisi object ko mutate karna, kabhi local stamp trigger nahi karte — kyunki dono mein se koi bhi naam ka binding nahi hai.

data = []
def add():
    data.append(5)   # no global needed
add()
print(data)          # [5]

KYU. data.append(5) mein kahin data = nahi aata. Name data sirf read hota hai (list dhundhne ke liye), phir list khud badal jaati hai. Step 3 ka rule sirf name ko bind karne pe fire hota hai. Compare karo: data = data + [5] data ko bind karta aur global ki zaroorat padti. Dekho Mutable vs Immutable objects aur Pure functions and side effects.

PICTURE. Name data (read-arrow, green) heap pe rehne wale ek list object ki taraf point karta hai; .append seedha object ko poke karta hai. Koi note wapas nahi chipakta, isliye koi local stamp nahi aata.

Ek Picture Mein Summary

Yeh ek diagram saaton steps compress karta hai: ek name andar aata hai, hum poochte hain "reading hai ya binding?", aur arrows exactly dikhate hain ki woh kis room mein jaata hai — aur global / nonlocal binding ko kaise redirect karte hain.

Connections

• global and nonlocal keywords
• Scope and LEGB rule
• Functions in Python
• Closures
• Mutable vs Immutable objects
• UnboundLocalError
• Pure functions and side effects