Chapter 8: Scope and Modules — Variable कहाँ जीता है, Code कैसे Organize होता है

x = 50

def update():
    global x
    x = 200
    print("Andar:", x)

update()
print("Bahar:", x)

def outer():
    x = "outer value"

    def inner():
        nonlocal x       # global nahi, outer function ka x
        x = "modified by inner"
        print("Inner:", x)

    inner()
    print("Outer:", x)    # yah bhi badal gaya!

outer()

⚖️ global vs nonlocal — पूरी तुलना

# file: mymodule.py
def greet(name):
    print("Namaste,", name)

x = 100

import mymodule

mymodule.greet("Aditya")
print("x =", mymodule.x)

📦 Import के 3 तरीके (Chapter 6 का recap + विस्तार)

import mymodule                    # poora module — prefix zaroori
from mymodule import greet, x      # sirf selected members
from mymodule import *             # sab kuch (⚠ avoid — conflicts ho sakte hain)

🎯 __name__ == "__main__" — बहुत Important Pattern

# file: demo.py
def show():
    print("Inside demo module")

if __name__ == "__main__":
    print("Yah file directly chal rahi hai")
else:
    print("Yah kisi aur file me import hui hai")

import mymodule
mymodule.greet()   # "Hello from Version 1"

# ...ab mymodule.py file me badlaav kiya gaya...
# def greet(): print("Hello from Version 2")

import importlib
importlib.reload(mymodule)
mymodule.greet()   # "Hello from Version 2" — naya code aa gaya!

⚠️ कब उपयोगी है, कब सावधानी बरतें

• ✅ Jupyter/IDLE जैसे long-running sessions में testing के दौरान।
• ✅ किसी module file में change करने के बाद बिना restart किए test करना।
• ⚠️ Reload से पुराने global variables reset हो सकते हैं — सावधानी से उपयोग करें।

Q1. LEGB — Local जीतता है

x = "global"
def f():
    x = "local"
    print(x)
f()
print(x)

Q2. Enclosing Scope Access

def outer():
    y = "outer y"
    def inner():
        print(y)     # local me nahi, enclosing me hai
    inner()
outer()

Q3. global Keyword का असर

count = 5
def inc():
    global count
    count += 1
inc()
inc()
print(count)

Q4. nonlocal बनाम बिना keyword

def outer():
    n = 10
    def inner():
        n = 20     # nonlocal NAHI hai — yah NAYA local n hai
        print("Inner:", n)
    inner()
    print("Outer:", n)
outer()

Q5. Module Namespace — कोई Conflict नहीं

import mod1, mod2
print(mod1.x + mod2.x)

Q6. __name__ Check

if __name__ == "__main__":
    print("Direct run")
else:
    print("Imported")

Program 1 — Counter (global keyword का practical उपयोग)

visitors = 0

def new_visitor():
    global visitors
    visitors += 1
    print(f"Visitor #{visitors} aaya!")

new_visitor()
new_visitor()
new_visitor()
print("Total visitors:", visitors)

Program 2 — Counter Generator (nonlocal से closure)

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

my_counter = make_counter()
print(my_counter())
print(my_counter())
print(my_counter())

Program 3 — अपना Utility Module बनाना

# File: shape_utils.py
def rectangle_area(l, w):
    return l * w

def circle_area(r):
    return 3.14159 * r * r

if __name__ == "__main__":
    print("Testing shape_utils directly")

# File: main.py
import shape_utils
print(shape_utils.rectangle_area(5, 3))
print(shape_utils.circle_area(4))

Program 4 — Module से Available Functions देखना

import random

functions = [name for name in dir(random) if not name.startswith("_")]
print("Total public functions:", len(functions))
print("Kuch functions:", functions[:5])

• Scope = variable कहाँ accessible; Lifetime = कब तक memory में रहता है।
• LEGB Rule: Local → Enclosing → Global → Built-in — इसी क्रम में Python नाम ढूँढता है, जहाँ मिले वहीं रुक जाता है।
• global keyword — module-level variable को function के अंदर से modify करने के लिए; nonlocal — outer (enclosing) function के variable को nested function से modify करने के लिए।
• Module = .py file जिसे import करके उपयोग करें; import module, from module import x, import module as alias — 3 तरीके।
• __name__ == "__main__" — बताता है file direct चली या import हुई; module को dual-purpose बनाने की trick।
• Namespace = names का mapping; हर module का अपना independent namespace — same नाम के variable दो modules में बिना conflict के रह सकते हैं।
• Import process: sys.modules check → sys.path search → .pyc compile → memory load → sys.modules register। दोबारा import cached version उपयोग करता है।
• Module Reloading: importlib.reload(module) — बिना restart किए updated code लाने के लिए।

❓ A. Multiple Choice Questions (50)

📝 B. 15 Theory Questions (Short Answers)

1. Scope व Lifetime में अंतर बताइए।Scope बताता है variable कहाँ accessible है (कौन-से हिस्से में); Lifetime बताता है variable memory में कब तक रहता है — दोनों जुड़े हैं पर अलग concept हैं।
2. LEGB Rule क्या है? पूरा क्रम लिखिए।Python किसी नाम को खोजने का क्रम — Local (function के अंदर) → Enclosing (outer function) → Global (module-level) → Built-in (Python predefined)। जहाँ पहले मिले, वहीं रुक जाता है।
3. global keyword की ज़रूरत कब पड़ती है?जब function के अंदर किसी module-level (global) variable की value बदलनी हो — बिना global keyword के Python उसे नया local variable मान लेता है और UnboundLocalError देता है।
4. nonlocal keyword क्या करता है? global से कैसे अलग है?nonlocal nested function से outer (enclosing) function के variable को modify करने देता है — सिर्फ बीच वाले scope तक पहुँचता है, module-level तक नहीं (वहाँ तक global चाहिए)।
5. Module क्या है? उदाहरण दीजिए।Module एक .py file है जिसमें functions, variables, classes हों — इसे import करके दूसरी files में उपयोग किया जा सकता है। उदाहरण: math, random, या खुद बनाई mymodule.py।
6. Import के 3 तरीके लिखिए।import module_name (पूरा module, prefix चाहिए); from module_name import x (specific member, prefix नहीं चाहिए); import module_name as alias (छोटा नाम)।
7. __name__ == "__main__" पैटर्न क्यों उपयोगी है?यह बताता है कि file directly चलाई गई है या किसी और file में import हुई है। इस check से एक ही file को standalone script व reusable module दोनों तरह उपयोग कर सकते हैं।
8. Namespace क्या है?Names व उनकी values (objects) का mapping — एक dictionary जैसा। हर module, function का अपना namespace होता है, जिससे same नाम के variables बिना टकराए रह सकते हैं।
9. दो modules में same नाम के variable हों तो क्या होगा?कोई conflict नहीं होगा क्योंकि हर module का अपना independent namespace है — उन्हें module_name.variable_name से अलग-अलग access करते हैं (जैसे mod1.x और mod2.x)।
10. dir() function का उपयोग समझाइए।dir(module_name) module में मौजूद सभी names (functions, variables, classes) की list देता है — किसी भी module को explore करने का तरीका।
11. Import होने पर Python अंदर क्या steps करता है?पहले sys.modules में check (पहले से loaded?) → नहीं तो sys.path directories में search → module मिलने पर .pyc bytecode में compile → memory में load → sys.modules में register।
12. sys.path और sys.modules में अंतर बताइए।sys.path — directories की list जहाँ Python modules खोजता है (search paths)। sys.modules — पहले से load हो चुके modules की dictionary (cache)।
13. Module reloading क्यों ज़रूरी होती है? कैसे करते हैं?Development/testing के दौरान module file में बदलाव के बाद updated code लाने के लिए — बिना Python restart किए। importlib.reload(module_name) से।
14. globals() और locals() function क्या करते हैं?globals() current module के सभी global variables को dictionary में देता है; locals() current function के local variables dictionary में देता है — दोनों debugging में उपयोगी।
15. Same function नाम दो modules में हो तो कैसे handle करते हैं?दोनों modules import करके module_name.function_name() से अलग-अलग call करते हैं — जैसे greet1.hello() और greet2.hello() — namespace अलग होने से कोई टकराव नहीं होता।