Variable scope — LEGB rule (Local, Enclosing, Global, Built-in)

1.2.30 · Coding › Introduction to Programming (Python)

Scope exist kyun karta hai?

"Scope" kya hai? Code ka woh region jahan ek naam visible/usable hai. "Namespace" kya hai? Woh actual dictionary jo naam → objects ko map karti hai aur ek scope ko support karti hai.

Chaar scopes (woh rooms jinmein Python dhundta hai)

Figure — Variable scope — LEGB rule (Local, Enclosing, Global, Built-in)

Lookup kaise kaam karta hai — Python ki tarah trace karo

Worked example Ek naam padhna: kaun sa

x?

x = "global"            # G
def outer():
    x = "enclosing"     # E
    def inner():
        x = "local"     # L
        print(x)
    inner()
outer()                 # prints: local

Kyun? inner ke andar, x pehle L mein mil jaata hai → "local". Python kabhi E ya G tak nahi pohonchta.

Ab local line delete karo:

def inner():
    print(x)            # no local x

Kyun? L mein koi x nahi → E check karo (outer ka x = "enclosing") → mil gaya. "enclosing" print hoga.

Worked example Built-in tak seedha pahunchna

print(len("hi"))   # 2

Yeh step kyun? len Local, Enclosing, ya Global mein nahi hai → B (built-ins) mein mila. Isliye len bina import kiye "bas kaam karta hai".

Steel-man danger: agar tum module level par len = 5 likhte ho, tum built-in ko shadow kar dete ho. Ab len("hi") → TypeError kyunki G, B se pehle check hota hai.

Crucial twist: assignment ek LOCAL naam banata hai

Worked example Classic

UnboundLocalError

count = 0
def bump():
    count = count + 1   # 💥 UnboundLocalError
bump()

Yeh kyun fail hota hai: Kyunki count = appear hota hai, count poore bump mein Local hai. Toh count + 1 ek local ko read karne ki koshish karta hai jo abhi assign nahi hua → error. Python kabhi global count nahi dekhta. Yeh step kyun important hai: read aur write dono ek hi (local) naam ko refer karte hain, aur read tab hoti hai jab write abhi exist hi nahi karti.

Fix karna: `global` aur `nonlocal`

Worked example Dono keywords action mein

count = 0
def bump():
    global count
    count = count + 1     # ab global ko edit karta hai
bump(); print(count)      # 1
 
def outer():
    n = 0
    def inner():
        nonlocal n
        n += 1            # outer ka n edit karta hai
    inner(); inner()
    return n
print(outer())            # 2

global kyun kaam karta hai: yeh Python ko bolta hai "count ke liye local-creation rule skip karo." nonlocal kyun kaam karta hai: yeh naam ko E ki taraf point karta hai, L ya G ki taraf nahi — bilkul wahi jo closures ko chahiye.

Read vs. write — woh rule jo sab kuch unify karta hai

Operation	Python kya karta hai
Read `x`	L → E → G → B search karo, pehla hit jeetega
Write `x = …` (bina keyword)	Hamesha Local banata/use karta hai
Write `global x` ke saath	Global ko target karta hai
Write `nonlocal x` ke saath	Enclosing ko target karta hai

Common mistake Galat mental models ko steel-man karna

Galat idea 1: "Functions global variables dekh sakte hain, toh main unhe change bhi kar sakta hoon." Kyun sahi lagta hai: tum function ke andar se globals read kar sakte ho, toh editing symmetric lagti hai. Fix: reading ≠ writing. Writing ek fresh local banata hai jab tak tum global nahi kehte.

Galat idea 2: "nonlocal aur global same hain." Kyun sahi lagta hai: dono tumhe ek outer variable modify karne dete hain. Fix: nonlocal enclosing function (E) ko target karta hai, global module (G) ko. nonlocal error deta hai agar koi enclosing variable nahi hai.

Galat idea 3: "Loops aur if blocks apna scope rakhte hain." Kyun sahi lagta hai: kaafi languages (C, Java) {} blocks se scope karte hain. Fix: Python mein, sirf functions, modules, aur comprehensions scope banate hain. Ek if/for mein assign kiya gaya variable enclosing function/module scope mein rehta hai.

Recall Feynman: ek 12-saal ke bacche ko samjhao

Socho tum poochh rahe ho "Mere joote kahan hain?" Tum pehle apna kamra check karte ho (Local), phir bade bhai ka kamra (Enclosing), phir darwaze ke paas ki jagah (Global), aur finally woh joote ki dukaan jo hamesha joote rakhti hai (Built-in). Tum pehli pair jo milti hai woh le lete ho aur dhundna band kar dete ho. Lekin ek twist hai: agar tum kabhi kehte ho "Main joote YAHAN apne kamre mein rakhunga" (shoes = ...), Python maanta hai poore din joote tumhare kamre mein hain — toh agar tum unhe rakhne se pehle pehanna chaho, tum naange pair khadé ho aur confused ho (yahi hai UnboundLocalError). global kehna aise hai jaise sabko batao "mera matlab darwaze wale joote hain, mere nahi."

Active Recall

LEGB stands for

Local, Enclosing, Global, Built-in — woh order jisme Python ek naam padhte waqt dhundta hai.

First-match rule in LEGB

Python PEHLA scope (L→E→G→B order mein) use karta hai jisme naam hota hai aur dhundna band kar deta hai.

Which scope is searched first

Local (current function ke khud ke assigned names).

Which scope is searched last

Built-in (jaise len, print, range, sum).

Why does x = x + 1 cause UnboundLocalError for a global x

Assignment x ko poore function mein local bana deta hai, toh assign hone se pehle x read karna fail ho jaata hai; Python global ko kabhi consult nahi karta.

What does global x do

Function ko batata hai ki x module-level (Global) naam ko refer karta hai, toh assignments global ko rebind karte hain.

What does nonlocal x do

x ko nearest ENCLOSING function ke variable se bind karta hai; assignments use edit karte hain, aur woh variable pehle se exist karna chahiye.

Difference between global and nonlocal

global module scope (G) ko target karta hai; nonlocal enclosing function scope (E) ko target karta hai.

Do for/if blocks create scope in Python

Nahi — sirf functions, modules, aur comprehensions scope banate hain; unke naam enclosing function/module scope mein jaate hain.

What is shadowing a built-in

L/E/G level par ek naam (jaise len) define karna taaki Python use built-in se pehle dhoondh le aur original chhup jaaye.

Reading vs writing rule

Reading L→E→G→B dhundti hai; writing (bina keyword) hamesha ek Local naam banata/use karta hai.

Connections

Functions and Parameters — scope banaya jaata hai function calls se.
Closures and Nested Functions — Enclosing scope (E) par rely karte hain.
Namespaces and the dict model — scopes dictionaries se backed hain.
Mutable vs Immutable arguments — function ke andar list mutate karna ≠ use rebind karna.
NameError and UnboundLocalError — LEGB ke direct consequences.
Modules and import — import Global namespace ko populate karta hai.