global and nonlocal keywords: Worked examples — Hinglish deep dive

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

Yeh note global and nonlocal keywords ka worked-examples companion hai. Parent note ne aapko do rules sikhaye the:

Ek function ke andar kisi bhi jagah kisi naam ko assign karna usse local bana deta hai poore function body ke liye (yeh compile time pe decide hota hai).
global module top level tak pahunchta hai; nonlocal nearest enclosing function tak pahunchta hai.

Yahan hum sirf har possible case ko run karte hain taaki koi bhi scenario aapko surprise na kare. Agar neeche koi word unfamiliar lage (scope, closure, rebind), toh parent note aur Scope and LEGB rule usse define karte hain — hum sirf unhi ko assume karte hain.

Scenario matrix

Is topic se jo bhi situation aa sakti hai woh is table ke ek cell mein hai. Neeche ke examples mein har ek tagged hai apne cell(s) ke saath, aur milke yeh sab poora fill karte hain.

#	Case class	Kya keyword chahiye?	Kaunsa?
C1	Sirf outer variable padho (read-only)	Nahi	—
C2	Ek module variable ko rebind karo	Haan	`global`
C3	Ek enclosing-function variable ko rebind karo	Haan	`nonlocal`
C4	Ek object (list/dict) ko mutate karo — naam pe `=` nahi	Nahi	—
C5	Degenerate: pehle rebind, phir read, no keyword	Crash hoga	`UnboundLocalError`
C6	Wrong keyword: `nonlocal` ki jagah `global`	Crash / miss	`SyntaxError` ya galat var
C7	Zero enclosing scopes: module top / ek level pe `nonlocal`	Crash hoga	`SyntaxError`
C8	Deep nesting — `nonlocal` sirf nearest enclosing pick karta hai	Haan	`nonlocal` (nearest)
C9	Real-world word problem (shared counter / config)	Haan	`global`
C10	Exam twist: `global` ek module var create karta hai jo pehle tha hi nahi	Haan	`global`

Example 1 — Sirf outer variable padho (C1)

Worked example

greeting = "hi"
def show():
    print(greeting)     # no keyword
show()

Forecast: Crash hoga, ya kuch print hoga?

Step 1 — Pucho: kya show ke andar greeting ko target karta koi = hai? Yeh step kyun? Locality rule sirf assignment par fire karta hai. Poora function body scan karo: koi greeting = ... nahi hai. Toh greeting local nahi hai.

Step 2 — Reading LEGB mein upar chadti hai. Yeh step kyun? Python Local (kuch nahi) → Enclosing (koi nahi) → Global ("hi" mila) dekhta hai. Reading hamesha baahir ki taraf search karti hai, koi keyword nahi chahiye (dekhein Scope and LEGB rule).

Verify: Output hai hi. Sanity check: humne kabhi greeting ko rebind nahi kiya, toh module ki value unchanged hai — ek pure read.

Example 2 — Classic crash (C5)

Worked example

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

Forecast: count upar clearly 0 hai — kya count + 1 se 1 milega?

Step 1 — Assignment target dhoondo. Yeh step kyun? count = count + 1 mein count assign ho raha hai. Compile-time rule se, count ab bump ke poore body ke liye local hai — right-hand side bhi included hai.

Step 2 — Right-hand side evaluate karo. Yeh step kyun? count + 1 ko local count read karna padega — lekin us local ko abhi tak koi value assign nahi hui. Python refuse karta hai.

Verify: UnboundLocalError: local variable 'count' referenced before assignment raise hota hai (dekhein UnboundLocalError). Example 3 mein fix hai.

Example 3 — Module variable ko rebind karo (C2)

Worked example

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

Forecast: Teen calls ke baad, kya count = 1, 2, ya 3 hoga?

Step 1 — global count locality decision cancel kar deta hai. Yeh step kyun? Ab bump mein har count module count ko mean karta hai. Right-hand side 0 read karta hai (phir 1, phir 2), koi crash nahi.

Step 2 — Har call global ko rebind karta hai. Yeh step kyun? Call 1: 0→1. Call 2: 1→2. Call 3: 2→3. State module level par calls ke beech persist karti rehti hai.

Verify: 3 print hota hai.

Example 4 — Mutate karo, rebind mat karo (C4)

Worked example

items = []
def add(x):
    items.append(x)     # no global!
add(1); add(2)
print(items)

Forecast: Kya yeh count ki tarah UnboundLocalError raise karega?

Step 1 — Kya koi = items ko target kar raha hai? Yeh step kyun? items.append(x) object par ek method call hai — koi items = ... nahi hai. Toh items local nahi banta; locality rule kabhi fire hi nahi karta.

Step 2 — items LEGB se read hota hai, phir in-place mutate hota hai. Yeh step kyun? Python items ko Global scope se read karta hai (reading baahir ki taraf chadti hai), list object milta hai, aur usme append karta hai. Naam abhi bhi same list ko point karta rehta hai.

Verify: [1, 2] print hota hai. C2 se contrast: rebinding ke liye global chahiye; mutating ke liye kabhi nahi.

Example 5 — Closure with nonlocal (C3)

Worked example

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

Forecast: 1 2 3, ya har call 1 se reset hoti hai?

Step 1 — n kahan rehta hai? Yeh step kyun? n = 0 make_counter mein hai, jo step ka enclosing function hai — module nahi. Toh target scope E hai, G nahi.

Step 2 — step n ko rebind karta hai (n += 1 matlab n = n + 1). Yeh step kyun? Naam par += ek rebind hai. nonlocal ke bina, step ek fresh local n banata aur use read karte waqt crash karta (closure ke andar C5). nonlocal n rebind ko enclosing n ki taraf point karta hai.

Step 3 — Closure n ko zinda rakhta hai. Yeh step kyun? make_counter return karne ke baad bhi, step (ek closure) n ka reference rakhta hai, toh yeh calls ke beech survive karta hai: 0→1→2→3.

Verify: 1 2 3 print hota hai.

Example 6 — Wrong keyword: enclosing var ke liye global (C6)

Worked example

def make_counter():
    n = 0
    def step():
        global n            # wrong!
        n += 1
        return n
    return step
c = make_counter()
print(c())

Forecast: Example 5 jaisa 1, ya kuch toot jaata hai?

Step 1 — global n MODULE ko dekhta hai, enclosing function ko nahi. Yeh step kyun? global hamesha ground floor tak pahunchta hai. Enclosing n = 0 usse invisible hai.

Step 2 — n += 1 ek module n read karta hai jo exist hi nahi karta. Yeh step kyun? Koi module-level n nahi hai, toh n + 1 NameError: name 'n' is not defined raise karta hai.

Verify: NameError raise hota hai. Rule: enclosing-function var ⇒ nonlocal, kabhi global nahi.

Example 7 — nonlocal bina kisi enclosing scope ke (C7)

Worked example

def solo():
    nonlocal y     # no enclosing function above solo
    y = 5

Forecast: Runtime crash, ya Python run karne se pehle hi reject kar deta hai?

Step 1 — nonlocal ko ek enclosing function mein existing binding chahiye. Yeh step kyun? solo module top level par hai; koi enclosing function nahi hai jo y hold kare. nonlocal ka koi target nahi hai.

Step 2 — Yeh compile time par pakda jaata hai. Yeh step kyun? UnboundLocalError (runtime error) ke unlike, ek galat nonlocal ek SyntaxError: no binding for nonlocal 'y' found hai — Python start bhi nahi hoga.

Verify: Definition time par SyntaxError raise hota hai.

Example 8 — Deep nesting: nonlocal sirf nearest enclosing pick karta hai (C8)

Worked example

def a():
    x = "a"
    def b():
        x = "b"
        def c():
            nonlocal x
            x = "c"
        c()
        return x
    return b(), x
 
print(a())

Forecast: Kya c b ka x badalta hai, a ka x, ya dono?

Step 1 — nonlocal NEAREST enclosing scope se bind karta hai jiske paas x ho. Yeh step kyun? c se baahir ki taraf chalte hain: b ke paas x = "b" hai — yahi nearest hai. c usi ko rebind karta hai, kabhi a ke x ko nahi.

Step 2 — Values trace karo. Yeh step kyun? c() b ke x ko "c" set karta hai. Toh b "c" return karta hai. a ka apna x "a" rehta hai, untouched.

Verify: ('c', 'a') print hota hai.

Example 9 — Real-world: shared config toggle (C9)

Worked example

Ek logging module mein ek switch hai. Use kahin se bhi on karna poore program ko affect karna chahiye.

DEBUG = False
def enable_debug():
    global DEBUG
    DEBUG = True
def log(msg):
    if DEBUG:
        print("LOG:", msg)
log("first")
enable_debug()
log("second")

Forecast: Kitni lines print hongi?

Step 1 — log sirf DEBUG read karta hai (C1): koi keyword nahi. Yeh step kyun? log mein koi = DEBUG ko target nahi karta; reading module value tak chadh jaati hai.

Step 2 — enable_debug DEBUG ko rebind karta hai (C2): global chahiye. Yeh step kyun? DEBUG = True module switch ki rebinding hai. global DEBUG usse shared variable par hit karta hai, ek throwaway local par nahi.

Step 3 — Trace karo. Yeh step kyun? log("first") → DEBUG False hai → kuch nahi. enable_debug() → module DEBUG = True. log("second") → LOG: second print karta hai.

Verify: Exactly ek line print hoti hai: LOG: second. (Yeh ek deliberate global side effect hai — pure function nahi.)

Example 10 — Exam twist: global ek naya module variable create karta hai (C10)

Worked example

def init():
    global created
    created = 99
init()
print(created)

Forecast: created init run hone se pehle kabhi module level par define nahi hua tha — NameError?

Step 1 — global created ek module variable naam leta hai jo abhi exist nahi karta. Yeh step kyun? global ko variable ka pehle se exist karna zaroori nahi. Yeh sirf kehta hai "naam created module scope ko refer karta hai."

Step 2 — Assignment use wahan create karta hai. Yeh step kyun? created = 99 ek naya module-level naam bind karta hai. init() run hone ke baad, module scope mein ab created = 99 hai.

Verify: 99 print hota hai. Note: yeh sirf init() call hone ke baad exist karta hai — init() se pehle print(created) call karna NameError raise karega.

Recall Yeh kaunsa cell hai? Quick self-test

total = 0
def add(v):
    total += v
add(5)

Answer ::: Cell C5 — total += v total ko rebind karta hai, use local banata hai; RHS assignment se pehle use read karta hai → UnboundLocalError. global total se fix karo.

Connections

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