Python Variable Scope (Local, Global, Nonlocal)

1. Local Scope

def show_value():
    x = 10  # Local variable
    print(x)

show_value()
# print(x)  # NameError: x is not defined

Local variables exist only within the function where they are declared.

---

2. Global Scope

x = 20  # Global variable

def display():
    print(x)

display()
print(x)

Global variables are accessible throughout the module.

---

3. Local vs Global Variable Conflict

value = 50

def update():
    value = 10  # Local variable shadows global
    print("Inside function:", value)

update()
print("Outside function:", value)

Local variables override global variables within function scope.

---

4. Using the global Keyword

count = 0

def increment():
    global count
    count += 1

increment()
print(count)  # Output: 1

The global keyword allows modification of global variables inside functions.

---

5. Enclosing Scope (Nested Functions)

def outer():
    message = "Hello"

    def inner():
        print(message)  # Accessing enclosing variable

    inner()

outer()

Nested functions can access variables from their enclosing scope.

---

6. Using the nonlocal Keyword

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        print(count)

    inner()
    inner()

outer()

nonlocal allows modification of variables from the enclosing (but not global) scope.

---

7. LEGB Rule (Scope Resolution Order)

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        x = "Local"
        print(x)

    inner()

outer()

Python resolves variables using the LEGB rule:

• Local

• Enclosing

• Global

• Built-in

---

8. Built-in Scope

print(len([1, 2, 3]))  # Built-in function

Built-in functions and exceptions reside in the built-in scope.

---

9. Scope Inside Loops

for i in range(3):
    loop_var = i

print(loop_var)  # Accessible outside loop

Unlike some languages, Python loop variables are not block-scoped.

---

10. Practical Example of Scope Management

total = 100

def calculate():
    total = 50

    def adjust():
        nonlocal total
        total += 10

    adjust()
    return total

print(calculate())  # Output: 60
print(total)        # Output: 100

Demonstrates coordinated use of local, enclosing, and global scopes.

---

78. Python Variable Scope — Local, Global, and Nonlocal (Comprehensive Guide)

---

1. Concept Overview

Variable scope defines where a variable is accessible and modifiable within a Python program.

Python resolves variable names using the LEGB rule:

• Local – inside the current function

• Enclosing – inside outer (nested) functions

• Global – defined at module level

• Built-in – predefined by Python

Understanding scope prevents unpredictable behavior and subtle bugs.

---

2. Local Scope

Variables declared inside a function are local by default.

def calculate():
    total = 100
    print(total)

calculate()
# print(total)  # NameError

Characteristics:

• Exists only within the function

• Destroyed after function execution

• Safest and most predictable scope

---

3. Global Scope

Variables declared outside any function are global.

rate = 0.10

def compute_tax(amount):
    return amount * rate

print(compute_tax(1000))

Characteristics:

• Accessible throughout the module

• Persists during program execution

• Risk of unintended modification

---

4. Modifying Global Variables (global keyword)

Without global, Python treats variables as local.

counter = 0

def increment():
    global counter
    counter += 1

increment()
print(counter)  # 1

Use case:

• Configuration management

• Runtime system counters

• Must be used sparingly

---

5. Enclosing Scope (Nested Functions)

def outer():
    message = "Hello"

    def inner():
        print(message)
    inner()

outer()

The inner function can access variables from the enclosing function.

---

6. Modifying Enclosing Variables (nonlocal keyword)

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        return count

    print(inner())
    print(inner())

outer()

nonlocal allows nested functions to update variables from their enclosing scope.

---

7. LEGB Resolution Demonstration

x = "Global"

def outer():
    x = "Enclosing"
    
    def inner():
        x = "Local"
        print(x)

    inner()

outer()  # Output: Local

Resolution order: Local → Enclosing → Global → Built-in

---

8. Shadowing Variables

value = 10

def display():
    value = 5
    print(value)

display()
print(value)

Here, the local value hides the global value.

⚠️ Shadowing can cause confusion and unexpected behavior.

---

9. Built-in Scope

Python provides built-in identifiers:

print(len([1, 2, 3]))  # len is built-in

Avoid overwriting:

len = 100  # Bad practice

This breaks core functionality.

---

10. Scope Behavior in Conditional Blocks

def test():
    if True:
        x = 50
    print(x)

test()

Python does not support block-level scope — variables exist at function level.

---

Scope Hierarchy Summary

Scope Type	Where It Exists	Keyword Control
Local	Inside function	Default
Enclosing	Nested functions	nonlocal
Global	Module-level	global
Built-in	Python engine	N/A

---

Variable Lifetime with Scope

Scope	Lifetime
Local	During function execution
Enclosing	As long as closure exists
Global	Program runtime
Built-in	Python session lifetime

---

Real-World Enterprise Example

config = {"rate": 0.05}

def pricing_engine():
    multiplier = 2

    def calculate(price):
        nonlocal multiplier
        return price * multiplier * config["rate"]

    return calculate

engine = pricing_engine()
print(engine(1000))

Demonstrates:

• Global config

• Enclosing state

• Closure-powered persistence

---

Common Mistakes

• Forgetting global when updating variables

• Misusing nonlocal

• Shadowing variables unintentionally

• Overusing global data

• Redefining built-in identifiers

---

Performance & Architectural Impact

Poor Scope Practice	Impact
Heavy globals	Tight coupling
Deep nesting	Reduced readability
Shadowing	Debugging complexity
Global mutation	Concurrency bugs

---

Best Practices

• Prefer local variables

• Minimize global scope usage

• Use nonlocal for closure state only

• Avoid variable name reuse

• Use function parameters instead of globals

---

Enterprise Importance

Mastery of variable scope ensures:

• Predictable behavior

• Thread-safe design

• Memory efficiency

• Clean modular architecture

• Debug-friendly systems

Critical for:

• Distributed services

• AI pipelines

• Concurrent systems

• Financial platforms

• Backend infrastructure

---

Comparison: Local vs Global vs Nonlocal

Feature	Local	Global	Nonlocal
Accessibility	Function only	Entire module	Nested function
Modification	Direct	Requires global	Requires nonlocal
Safety	High	Low	Moderate

---

Architectural Value

Correct scope handling enables:

• Reliable microservices

• Clean dependency management

• Predictable execution flow

• Robust state control

• Scalable codebases

---