🌱 Junior Track 10 of 10

10. Scope & Namespaces

Master variable resolution & symbol isolation: `Local scope`, `Enclosing scope`, `Global scope`, `Built-in scope`, the `LEGB rule`, scope modifiers (`global` & `nonlocal`), and runtime namespace inspection (`locals()` & `globals()`).

← 9. *args & **kwargs ⭐ Practice 100+ Python Questions →

👁️ Views: 0

🎓 Junior Python Curriculum — Select Module

1️⃣ Fundamentals 2️⃣ Data Types 3️⃣ Operators 4️⃣ Conditionals 5️⃣ Loops 6️⃣ Collections 7️⃣ Comprehensions 8️⃣ Functions 9️⃣ *args & **kwargs 🔟 Scope & Namespaces 1️⃣1️⃣ OOP 1️⃣2️⃣ Exceptions 1️⃣3️⃣ File Handling 1️⃣4️⃣ Modules & Packages 1️⃣5️⃣ Virtual Environments 1️⃣6️⃣ Standard Library 1️⃣7️⃣ Iterators & Iterables 1️⃣8️⃣ Generators 1️⃣9️⃣ Decorators 2️⃣0️⃣ Context Managers 2️⃣1️⃣ Lambda Functions 2️⃣2️⃣ Functional Programming 2️⃣3️⃣ Type Hints 2️⃣4️⃣ Dataclasses 2️⃣5️⃣ Testing 2️⃣6️⃣ Debugging 2️⃣7️⃣ Logging 2️⃣8️⃣ JSON & Data 2️⃣9️⃣ Regular Expressions 3️⃣0️⃣ Databases

# ==============================================================================
# JUNIOR PYTHON TRACK 10 — SCOPE & NAMESPACES (LEGB RULE)
# ==============================================================================

# G: Global Scope Variable
global_counter: int = 100

def outer_function():
    # E: Enclosing Scope Variable
    enclosing_val: str = "Enclosing Scope"
    
    def inner_function():
        # L: Local Scope Variable
        local_val: str = "Local Scope"
        
        # Modifying Enclosing Scope variable with nonlocal
        nonlocal enclosing_val
        enclosing_val = "Modified Enclosing Scope"
        
        # Modifying Global Scope variable with global
        global global_counter
        global_counter += 1
        
        return {
            "local": local_val,
            "enclosing": enclosing_val,
            "global": global_counter,
            "builtin_len": len([1, 2, 3])  # B: Built-in Scope function
        }
        
    res = inner_function()
    return res, enclosing_val

def inspect_namespaces():
    """Demonstrates runtime namespace inspection via locals() & globals()."""
    x = 42
    y = "Python"
    local_dict = locals()  # Returns dictionary of local namespace symbol table
    return f"Local Namespace keys: {list(local_dict.keys())}"

if __name__ == "__main__":
    print("--- LEGB Scope Resolution ---")
    result, updated_enclosing = outer_function()
    print(f"Inner Function Result: {result}")
    print(f"Updated Global Counter: {global_counter}")
    print(inspect_namespaces())

$ python3 junior_scope.py
--- LEGB Scope Resolution ---
Inner Function Result: {'local': 'Local Scope', 'enclosing': 'Modified Enclosing Scope', 'global': 101, 'builtin_len': 3}
Updated Global Counter: 101
Local Namespace keys: ['x', 'y', 'local_dict']
Execution completed successfully.

import unittest

class TestJuniorScope(unittest.TestCase):
    def test_nonlocal_modification(self):
        def counter_closure():
            count = 0
            def increment():
                nonlocal count
                count += 1
                return count
            return increment
        
        c = counter_closure()
        self.assertEqual(c(), 1)
        self.assertEqual(c(), 2)

if __name__ == "__main__":
    unittest.main()

🌱 Junior Track 10 Master Reference

10. Python Scope, Namespaces & LEGB Resolution Rule

1️⃣ The LEGB Resolution Pyramid

When Python encounters a variable name, it searches through four distinct scope levels in strict order:

                    [L]ocal Scope         --> Inside current function

                    [E]nclosing Scope     --> Inside outer enclosing functions (closures)

                    [G]lobal Scope       --> Top-level module file

                    [B]uilt-in Scope     --> Built-in Python keywords & functions

2️⃣ Local Scope (`L`)

Variables assigned inside a function belong exclusively to that function's local scope. They are created when the function is invoked and destroyed upon return.

                    def calculate_tax(amount):

                        rate = 0.2  # 'rate' is Local to calculate_tax

                        return amount * rate

3️⃣ Enclosing Scope (`E`) & `nonlocal` Keyword

Enclosing scope exists in nested functions. To modify an outer function's variable from an inner function, use the nonlocal keyword.

                    def make_counter():

                        count = 0  # Enclosing variable

                        def increment():

                            nonlocal count

                            count += 1

                            return count

                        return increment

4️⃣ Global Scope (`G`) & `global` Keyword

Global variables are declared at module file level. To modify a global variable inside a function body, you must declare it using global.

                    app_status = "STARTING"  # Global variable

                    def set_ready():

                        global app_status

                        app_status = "READY"

5️⃣ Python Namespaces (`locals()` & `globals()`)

A Namespace is a dictionary mapping variable names (keys) to objects (values). You can inspect runtime namespaces using built-in functions:

                    print(locals())   # Dictionary of local variable name-to-object bindings

                    print(globals())  # Dictionary of module-level global bindings

← 9. *args & **kwargs 🌱 Junior Hub 11. OOP →