Global और Local Variable — Python का scope नियम

दो तरह के variable

Python में variable कहाँ बना, उससे तय होता है वो कहाँ तक दिखेगा। इसी को scope कहते हैं।

count = 0                 # global — module level पर बना

def increment():
    step = 1              # local — function के अंदर बना
    return count + step   # global को पढ़ सकता है ✅

increment()
print(count)              # 0 — बदला नहीं
print(step)               # NameError: name 'step' is not defined

दो नियम यहीं से निकलते हैं। Function के अंदर बना variable बाहर नहीं दिखता। और function global variable को पढ़ सकता है, लेकिन उसे बदल नहीं सकता — कम से कम बिना बताए नहीं।

LEGB नियम — Python नाम कहाँ ढूँढता है

जब Python किसी नाम को resolve करता है, वो चार जगह इसी क्रम में देखता है:

• L — Local: उसी function के अंदर।
• E — Enclosing: बाहर लपेटे हुए function के अंदर (nested functions में)।
• G — Global: module level पर।
• B — Built-in: len, print, range जैसे Python के अपने नाम।

पहली जगह जहाँ नाम मिल जाए, वही जीतता है। इसीलिए एक variable बनाना कभी-कभी किसी built-in function को ढक देता है:

def bad():
    list = [1, 2, 3]      # 'list' को local नाम बना दिया
    return list(range(3)) # TypeError: 'list' object is not callable

# इसी तरह len, sum, max, id, input, type, str — इन नामों से variable मत बनाओ

UnboundLocalError — सबसे आम confusion

यही वो error है जो scope को समझने के लिए सबसे ज़्यादा लोगों को मजबूर करता है। ये NameError नहीं है, अलग error है:

count = 0

def increment():
    count = count + 1     # UnboundLocalError: local variable
                          # 'count' referenced before assignment

increment()

वजह counter-intuitive है, पर नियम साफ है: अगर किसी नाम पर function के अंदर कहीं भी assignment है, तो Python उसे पूरे function के लिए local मान लेता है। ये तय compile के समय होता है, चलने के समय नहीं।

तो count = count + 1 में बाईं ओर वाला count assignment है — इसका मतलब count local है। अब दाईं ओर उसे पढ़ने की कोशिश होती है, लेकिन local count को अभी कोई value मिली नहीं। इसलिए error। Global count यहाँ देखा ही नहीं जाता।

# proof — assignment हटाओ, error गायब
count = 0

def read_only():
    print(count)          # ✅ 0 — सिर्फ पढ़ रहा है, तो global मिलता है

# assignment के बाद वही पढ़ना fail होगा
def broken():
    print(count)          # UnboundLocalError — नीचे assignment है,
    count = 5             # इसलिए पूरा नाम local मान लिया गया

# नीचे import होने से भी फर्क नहीं पड़ता — नियम पूरे function पर लागू है

global keyword

global Python को बताता है कि ये नाम local नहीं बनाना, module level वाले को ही use करना है:

count = 0

def increment():
    global count
    count = count + 1     # ✅ अब global बदलता है

increment()
increment()
print(count)              # 2

दो बातें ध्यान देने लायक हैं। global function में कहीं भी लिखा हो, वो पूरे function पर लागू होता है — ऊपर-नीचे का क्रम मायने नहीं रखता। और ये सिर्फ rebind करने के लिए चाहिए; mutable object को बदलने के लिए नहीं:

items = []

def add(x):
    items.append(x)       # ✅ global keyword नहीं चाहिए
                          # items को rebind नहीं कर रहे, mutate कर रहे हैं

def replace(x):
    global items          # चाहिए, क्योंकि नाम नए object पर point होगा
    items = [x]

# इसी तरह dict और set पर भी
cfg = {}
def set_key(k, v):
    cfg[k] = v            # ✅ बिना global के

यही अंतर लोगों को सबसे ज़्यादा उलझाता है: items.append(x) बिना global के चलता है, पर items = [x] को global चाहिए। फर्क rebind बनाम mutate का है।

nonlocal — nested functions के लिए

जब function किसी दूसरे function के अंदर हो, तो enclosing scope के variable को बदलने के लिए nonlocal चाहिए:

def counter():
    total = 0
    def bump():
        nonlocal total        # enclosing scope, global नहीं
        total += 1
        return total
    return bump

c = counter()
print(c(), c(), c())          # 1 2 3

def counter():
    total = 0
    def bump():
        total += 1            # UnboundLocalError
        return total
    return bump

global module level तक जाता है, nonlocal सिर्फ एक level बाहर के enclosing function तक। दोनों एक ही नियम के नतीजे हैं — assignment नाम को उस scope का बना देता है जिसमें उसे declare किया गया हो।

global से बचना क्यों बेहतर है

global काम करता है, पर बड़े code में तीन सवाल खड़े करता है:

• Function अकेले टेस्ट नहीं हो सकता। उसे चलाने से पहले global state सही हालत में होना चाहिए, और हर टेस्ट के बाद उसे reset करना पड़ता है।
• Call order मायने रखने लगता है। f() फिर g() का नतीजा g() फिर f() से अलग हो सकता है — debug करना बहुत मुश्किल।
• पढ़ने वाला नहीं जानता कि कौन क्या बदलेगा। Function का signature झूठ बोलने लगता है।

# global वाला तरीका
count = 0
def increment():
    global count
    count += 1

# parameter वाला तरीका — वही काम, कोई छिपा state नहीं
def increment(count):
    return count + 1

count = increment(count)

नियम जो असल में काम आता है: function को जो चाहिए वो parameter से अंदर भेजो, और नतीजा return से बाहर भेजो। Global state सिर्फ तब रखो जब वो सचमुच config जैसा स्थिर हो — और तब भी उसे एक जगह इकट्ठा रखो, पूरे module में बिखेर कर नहीं।

Class attributes — तीसरा scope

Class के अंदर एक और scope जुड़ जाता है, और वहाँ global/nonlocal नहीं, self काम आता है:

class Counter:
    total = 0                  # class attribute — सब instances में साझा

    def __init__(self):
        self.count = 0         # instance attribute — हर object का अपना

    def bump(self):
        Counter.total += 1     # class वाला बदलना
        self.count += 1        # अपना बदलना

a, b = Counter(), Counter()
a.bump(); a.bump(); b.bump()
print(a.count, b.count, Counter.total)   # 2 1 3

self.count और Counter.total अलग-अलग चीज़ें हैं, और इस फर्क को भूलना class वाले code की सबसे आम गलती है। self लिखना भूलने पर नाम local बन जाता है और instance पर कुछ सेट ही नहीं होता।

🛠️ Practice करो (free, browser में)

पढ़ना काफी नहीं — यही bug खुद fix करके देखो। नीचे के problems browser में ही चलते हैं, कोई install नहीं, कोई login नहीं।

• Modifying a variable before it is assigned locally — यही UnboundLocalError वाला bug।
• Function returning nothing — return भूलने पर None मिलता है।

अक्सर पूछे जाने वाले सवाल

आगे पढ़ो

• UnboundLocalError का पूरा fix
• Python functions Hindi में
• Decorator Hindi में — closure का असली use
• *args और **kwargs Hindi में
• Hindi hub — सारे Hindi guides