Python Function Scopes — LEGB, Global vs Local

Why Scope Exists — The Rooms in Your House 🏠Scope क्यों होता है — आपके घर के कमरे 🏠为什么需要作用域 — 你家里的房间 🏠

A scope is the part of a program where a name (a variable, function or class) can be used directly. Python decides which value a name means by looking through scopes in a fixed order. Knowing that order is the difference between "the code works" and "I have no idea why the code works".

Scope program का वह हिस्सा है जहाँ कोई नाम (variable, function या class) सीधे इस्तेमाल हो सकता है। Python तय क्रम में scopes देखकर तय करता है कि किसी नाम का मतलब कौन-सी value है। वह क्रम जानना ही "code चलता है" और "मुझे नहीं पता code क्यों चलता है" के बीच का अंतर है।

作用域 是程序中可以直接使用某个名字（变量、函数或类）的区域。Python 按固定顺序查看各个作用域，来决定一个名字对应哪个值。懂得这个顺序，就是 "代码能跑" 和 "我不知道代码为什么能跑" 之间的区别。

The LEGB Rule — Python's Lookup Order 🔍LEGB नियम — Python का खोजने का क्रम 🔍LEGB 规则 — Python 的查找顺序 🔍

Whenever Python reads a name, it searches four scopes in this exact order and stops at the first match. Learn the acronym LEGB and most scope confusion disappears.

जब भी Python कोई नाम पढ़ता है, वह ठीक इसी क्रम में चार scopes खोजता है और पहला मेल मिलते ही रुक जाता है। LEGB याद कर लें, तो scope की ज़्यादातर उलझन ख़त्म हो जाती है।

每当 Python 读取 一个名字时，它都会严格按这个顺序搜索四个作用域，找到第一个匹配就停下。记住缩写 LEGB，大部分作用域困惑就消失了。

# Global scope
x = "global-x"

def outer():
    x = "enclosing-x"              # Enclosing scope

    def inner():
        x = "local-x"              # Local scope
        print("inside inner:", x)   # finds Local first

    inner()
    print("inside outer:", x)       # finds Enclosing

outer()
print("module level: ", x)          # finds Global
print(len(x))                       # len comes from Built-in

A LEGB Side Effect — Hiding a Built-inLEGB का एक असर — Built-in को छिपा देनाLEGB 的副作用 — 遮住内置名字

Because Global is checked before Built-in, a global name can hide a built-in one. Calling a variable list, str or sum is a classic beginner bug.

क्योंकि Global, Built-in से पहले जाँचा जाता है, इसलिए कोई global नाम built-in को छिपा सकता है। Variable का नाम list, str या sum रखना नए सीखने वालों का मशहूर bug है।

因为全局作用域在内置作用域 之前 被检查，全局名字可以遮住内置名字。把变量命名为 list、str 或 sum 是初学者的经典 bug。

list = ["a", "b"]              # a GLOBAL name now hides the built-in list

print(list)
try:
    letters = list("xyz")      # LEGB finds the global first!
except TypeError as e:
    print("TypeError:", e)

del list                       # remove the global name...
print(list("xyz"))             # ...and the built-in is visible again

Try It — LEGB Name Finderकरके देखें — LEGB Name Finder动手试试 — LEGB 名字查找器

Tick where x exists, choose where the print happens, and press Find it. Python searches the rings from the inside out and stops at the first match. Try printing from outer — the inner room is invisible from there.

जहाँ x मौजूद है वहाँ tick करें, चुनें कि print कहाँ होता है, और खोजें दबाएँ। Python घेरों को अंदर से बाहर की ओर खोजता है और पहला मेल मिलते ही रुकता है। outer से print करके देखें — वहाँ से अंदर का कमरा दिखता ही नहीं।

勾选 x 存在的位置，选择 print 发生在哪里，然后按 查找。Python 从内向外搜索各圈，找到 第一个 匹配就停下。试试在 outer 里打印 — 从那里看不到内层房间。

Local Scope — What Happens Inside a Function Stays Inside 🚪Local Scope — Function के अंदर जो हुआ, अंदर ही रहता है 🚪局部作用域 — 函数内部的事留在内部 🚪

Any name that Python sees being assigned inside a function body is local to that function — unless you mark it global or nonlocal. This "local by default" rule is Python's most important scope decision.

Function body के अंदर जिस भी नाम को Python assign होते देखता है, वह उस function का local है — जब तक आप उसे global या nonlocal न लिखें। यह "default रूप से local" नियम Python का सबसे अहम scope फ़ैसला है।

凡是 Python 在函数体内看到被 赋值 的名字，都是这个函数的局部变量 — 除非你把它标为 global 或 nonlocal。这条 "默认局部" 规则是 Python 最重要的作用域决定。

def make_greeting():
    message = "Hello"              # local to make_greeting
    count   = 3                    # local to make_greeting
    print(message, count)

make_greeting()
print(message)                     # NameError — message does not exist here

Each Call Gets a Fresh Local Scopeहर Call को नया Local Scope मिलता है每次调用都得到全新的局部作用域

def counter():
    n = 0                       # fresh n on every call
    n += 1
    print(f"n = {n}")

counter()
counter()
counter()

Try It — Scope Playgroundकरके देखें — Scope Playground动手试试 — 作用域游乐场

Step through real programs. Each function call opens a new room with its own whiteboard; the room is torn down when the call returns. Under each step you can see how Python searched for every name it read.

असली programs को कदम-दर-कदम चलाएँ। हर function call अपने whiteboard के साथ एक नया कमरा खोलता है; call लौटते ही कमरा हटा दिया जाता है। हर कदम के नीचे आप देख सकते हैं कि Python ने पढ़े गए हर नाम को कैसे खोजा।

一步步执行真实程序。每次函数调用都会打开一个带白板的新 房间；调用返回时房间被拆除。每一步下方都能看到 Python 是怎样查找它读取的每个名字的。

Reading Globals from Inside a Function — Works Fine 📖Function के अंदर से Globals पढ़ना — ठीक चलता है 📖在函数内读取全局变量 — 完全没问题 📖

You can read a global variable from inside a function with no special syntax. Python's LEGB search finds it in the Global scope after failing to find it Locally. No error, no ceremony.

आप function के अंदर से global variable को बिना किसी ख़ास syntax के पढ़ सकते हैं। Python की LEGB खोज उसे Local में न पाकर Global scope में ढूँढ लेती है। न error, न कोई झंझट।

你可以在函数内部直接 读取 全局变量，不需要任何特殊语法。Python 的 LEGB 搜索在局部找不到后，会在全局作用域找到它。没有错误，没有麻烦。

APP_NAME = "PaymentService"       # global
VERSION  = "2.4.1"               # global

def show_banner():
    # Only READING globals — perfectly legal
    print(f"=== {APP_NAME} v{VERSION} ===")

show_banner()
show_banner()

The Famous Trap — UnboundLocalError 💥मशहूर जाल — UnboundLocalError 💥著名陷阱 — UnboundLocalError 💥

counter = 0                        # global

def bump():
    print("before:", counter)      # seemed fine before...
    counter += 1                    # ...but this line changes EVERYTHING
    print("after: ", counter)

bump()

What Python Actually SeesPython असल में क्या देखता हैPython 实际看到的

Try It — Watch the Trap Happenकरके देखें — जाल को होते देखें动手试试 — 看陷阱如何发生

Look at the compiler's decisions panel first: counter is already marked LOCAL because of the += line. Then step to the print and watch Python look in the local room, find it empty, and stop — it never checks the global room.

पहले compiler के फ़ैसले वाला हिस्सा देखें: += वाली line की वजह से counter पहले ही LOCAL मान लिया गया है। फिर print तक जाएँ और देखें कि Python local कमरे में देखता है, उसे ख़ाली पाता है, और रुक जाता है — वह global कमरा कभी नहीं जाँचता।

先看 编译器的决定 面板：因为 += 那一行，counter 已经被标为局部。然后一步步走到 print，看 Python 在局部房间里查找、发现是空的、然后停下 — 它从不检查全局房间。

The global Keyword — Reaching Out to Change Globals 🌍global Keyword — Globals बदलने के लिए बाहर पहुँचना 🌍global 关键字 — 向外修改全局变量 🌍

To really change a global variable from inside a function, declare it global at the top of the function. This tells Python: "don't make a local counter — use the module-level one".

Function के अंदर से global variable को सच में बदलने के लिए function के ऊपर उसे global घोषित करें। यह Python से कहता है: "local counter मत बनाओ — module-level वाला इस्तेमाल करो"।

要在函数内部真正修改全局变量，就在函数开头把它声明为 global。这是在告诉 Python："不要创建局部的 counter — 用模块级的那个"。

counter = 0                        # global

def bump():
    global counter               # "I mean THE module-level counter"
    print("before:", counter)
    counter += 1                    # now modifies the global
    print("after: ", counter)

bump()
bump()
bump()
print("final: ", counter)

Before vs After — What global Really Changesपहले बनाम बाद — global असल में क्या बदलता है之前与之后 — global 真正改变了什么

The Mutation Loophole — Why Lists and Dicts Seem to "Just Work" 🛒Mutation की छूट — Lists और Dicts "बस चल" क्यों जाते हैं 🛒修改的漏洞 — 为什么 list 和 dict 似乎 "直接就能用" 🛒

Here is something that trips up almost everyone. This code has no global declaration, and yet it works:

यह बात लगभग सबको उलझाती है। इस code में कोई global घोषणा नहीं है, फिर भी यह चलता है:

下面这一点几乎让所有人犯迷糊。这段代码 没有 global 声明，却照样能运行：

cart = []                            # global list

def add_item(item):
    cart.append(item)                # no 'global cart' needed?!

add_item("book")
add_item("pen")
print(cart)

cart = []

def reset_cart():
    cart = []                        # this is REBINDING -> creates a local!
    cart.append("fresh")

reset_cart()
print("global cart:", cart)         # still []

Try It — Mutation vs Rebindingकरके देखें — Mutation बनाम Rebinding动手试试 — 修改与重新绑定

Compare the tabs. With .append() or d[k] = v the name is only read and the global object changes. With cart = [] a new local name appears and the global list is left alone.

Tabs की तुलना करें। .append() या d[k] = v में नाम सिर्फ़ पढ़ा जाता है और global object बदलता है। cart = [] में एक नया local नाम आता है और global list अछूती रहती है।

比较这几个标签页。用 .append() 或 d[k] = v 时，名字只是被 读取，全局对象被修改。用 cart = [] 时，出现了一个 新的局部 名字，全局 list 保持不变。

Try It — Assignment Detectorकरके देखें — Assignment Detector动手试试 — 赋值检测器

Type one line to put inside a function (use ; for two lines). The detector answers the three questions from the table below, then runs the program for real. Don't miss lst += [4] — it looks like a mutation, but it is an assignment.

Function के अंदर रखने के लिए एक line लिखें (दो lines के लिए ; लगाएँ)। Detector नीचे की table वाले तीन सवालों का जवाब देता है, फिर program सच में चलाता है। lst += [4] ज़रूर आज़माएँ — यह mutation जैसा दिखता है, पर यह assignment है।

输入一行要放进函数里的代码（两行用 ; 分隔）。检测器会回答下表中的三个问题，然后真正运行程序。别错过 lst += [4] — 它看起来像修改，其实是赋值。

Enclosing Scope and the nonlocal Keyword 🪆Enclosing Scope और nonlocal Keyword 🪆外层作用域与 nonlocal 关键字 🪆

When one function is defined inside another, the outer function's variables form an enclosing scope for the inner one. The inner function can read them freely, but assigning makes a new local name — the same trap as with globals. To really change the enclosing variable, use nonlocal.

जब एक function दूसरे के अंदर बनता है, तो बाहरी function के variables अंदर वाले के लिए enclosing scope बनाते हैं। अंदर वाला function उन्हें आराम से पढ़ सकता है, पर assign करने पर नया local नाम बन जाता है — globals वाला ही जाल। Enclosing variable को सच में बदलने के लिए nonlocal इस्तेमाल करें।

当一个函数定义在另一个函数内部时，外层函数的变量就构成了内层函数的 外层 作用域。内层函数可以随意读取它们，但一赋值就会产生新的局部名字 — 和全局变量是同一个陷阱。要真正修改外层变量，请用 nonlocal。

def make_counter():
    count = 0                       # enclosing variable

    def increment():
        nonlocal count             # reach outward to enclosing scope
        count += 1
        return count

    return increment

tick = make_counter()
print(tick())
print(tick())
print(tick())

Try It — Closures and nonlocalकरके देखें — Closures और nonlocal动手试试 — 闭包与 nonlocal

Watch make_counter()'s room: normally it is destroyed when the call ends, but increment keeps using it. Every tick() writes to that same enclosing room. The two counters tab shows that each call to make_counter() gets its own separate room.

make_counter() का कमरा देखें: आम तौर पर call ख़त्म होते ही वह नष्ट हो जाता, पर increment उसे इस्तेमाल करता रहता है। हर tick() उसी enclosing कमरे में लिखता है। two counters tab दिखाता है कि make_counter() के हर call को अपना अलग कमरा मिलता है।

观察 make_counter() 的房间：通常调用结束时它就被销毁了，但 increment 还在用它。每次 tick() 都写入同一个外层房间。two counters 标签页显示，每次调用 make_counter() 都会得到各自独立的房间。

No Block Scope — Loops, if and Comprehensions 🔁Block Scope नहीं — Loops, if और Comprehensions 🔁没有块作用域 — 循环、if 与推导式 🔁

Many languages give each for loop or if block its own scope. Python does not. Only functions (and classes and modules) make a new scope. A loop variable stays alive after the loop. The one exception you will meet often: a list, set or dict comprehension has its own small scope.

कई भाषाएँ हर for loop या if block को अपना scope देती हैं। Python नहीं देता। सिर्फ़ functions (और classes व modules) नया scope बनाते हैं। Loop का variable loop के बाद भी ज़िंदा रहता है। एक अपवाद जो आपको अक्सर मिलेगा: list, set या dict comprehension का अपना छोटा scope होता है।

许多语言会给每个 for 循环或 if 块一个独立的作用域。Python 不会。只有函数（以及类和模块）会创建新的作用域。循环变量在循环结束后依然存在。你经常会遇到的一个例外是：list、set 或 dict 推导式 有自己的小作用域。

# Loops and if-blocks do NOT create a new scope
for i in range(3):
    square = i * i

print("i after the loop:", i)          # 2 — still alive
print("square after the loop:", square) # 4

if True:
    inside_if = "visible"
print(inside_if)                        # visible — no block scope

# But a comprehension DOES have its own scope
nums = [k * 10 for k in range(3)]
print(nums)
try:
    print(k)
except NameError as e:
    print("NameError:", e)

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆

Quick Checkछोटी जाँच小测验

Seven questions on scope. Pick an answer to see why.

Scope पर सात सवाल। जवाब चुनें और कारण देखें।

关于作用域的七道题。选择答案查看解释。