Python Variable Scope Guide: LEGB, global & nonlocal

1. Introduction: What is Python’s variable scope?

def my_function():
    x = 10  # This variable x is only valid within the function

print(x)  # NameError: name 'x' is not defined

2. Basics of Variable Scope

2.1 What Is Variable Scope?

2.2 Why Do You Need to Understand Scope?

• Unintended variable overwriting Using the same variable name in different scopes can lead to unexpected bugs.
• Variable not found (NameError) Attempting to access a variable without understanding its scope can raise a NameError.
• Reduced code readability Overusing global-scope variables makes the code’s intent unclear and debugging difficult.

2.3 Basic Rules of Python Scope

1. Variables defined inside a function are only valid within that function (local scope)
2. Variables defined outside functions are accessible throughout the script (global scope)
3. Python has a “LEGB rule” that defines the order of scope lookup
4. To modify a global variable inside a function, use the global keyword
5. To modify an outer variable in a nested function, use the nonlocal keyword

3. Types of Python Scopes and Examples

• Local Scope
• Enclosing Scope
• Global Scope
• Built-in Scope

3.1 Local Scope (Local Scope)

Example of Local Scope

def my_function():
    x = 10  # x is a local variable of this function
    print(x)  # This works fine

my_function()
print(x)  # NameError: name 'x' is not defined

3.2 Enclosing Scope (Enclosing Scope)

Example of Enclosing Scope

def outer_function():
    y = 20  # variable in the parent function's scope

    def inner_function():
        print(y)  # can reference the parent function's variable inside the child function

    inner_function()

outer_function()

3.3 Global Scope (Global Scope)

Example of Global Scope

z = 30  # global variable

def my_function():
    print(z)  # can access global variable

my_function()
print(z)  # can be referenced anywhere

3.4 Built-in Scope (Built-in Scope)

Example of Built-in Scope

print(len([1, 2, 3]))  # Output: 3

3.5 Summary of the Four Scopes

4. Variable Scope Lookup Order (LEGB Rule)

1. L (Local) Local Scope – Variables defined within the current function
2. E (Enclosing) Enclosing Scope – Variables of an outer function (nested function)
3. G (Global) Global Scope – Variables defined at the module level
4. B (Built-in) Built-in Scope – Built-in functions and variables provided by Python from the start

4.1 Concrete Example of the LEGB Rule

x = "global variable"  # G (Global)

def outer_function():
    x = "enclosing variable"  # E (Enclosing)

    def inner_function():
        x = "local variable"  # L (Local)
        print(x)  # According to the LEGB rule, refers to the innermost x

    inner_function()

outer_function()
print(x)  # Refers to the x in the global scope

Output

local variable
global variable

4.2 Effects of Global Scope

Attempting to modify a global variable locally causes an error

x = 10  # global variable

def update_x():
    x += 1  # error occurs
    print(x)

update_x()

Error Message

UnboundLocalError: local variable 'x' referenced before assignment

Solution: Use the global keyword

x = 10  # global variable

def update_x():
    global x  # explicitly specify the global variable
    x += 1
    print(x)

update_x()  # output: 11

4.3 Changing Scope Using nonlocal

Concrete Example of nonlocal

def outer_function():
    count = 0  # variable of the outer function

    def inner_function():
        nonlocal count  # refer to the variable of the outer function
        count += 1
        print(count)

    inner_function()
    print(f"Final count: {count}")

outer_function()

Output

1
Final count: 1

4.4 Searching Built-in Functions (Built-in Scope)

Example of Overriding a Built-in Function

sum = 100  # `sum()` is a built-in function, but it was overwritten as a variable

print(sum([1, 2, 3]))  # TypeError: 'int' object is not callable

Solution: Do Not Overwrite Built-in Functions

del sum  # remove the overwrite
print(sum([1, 2, 3]))  # works correctly

4.5 Summary of the LEGB Rule

5. Distinguishing Between Global and Local Variables

5.1 What Is a Global Variable?

Example of a Global Variable

count = 0  # Global variable

def increment():
    global count  # Use global variable
    count += 1

increment()
print(count)  # Output: 1

5.2 What Is a Local Variable?

of a Local Variable

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

my_function()
print(x)  # NameError: name 'x' is not defined

5.3 global Cases Where You Should Use the Keyword

Appropriate Cases

• When managing configuration values or constants
• When multiple functions need to share the same variable

Example: Managing Configuration Values

MAX_USERS = 100  # Global variable (treated as a constant)

def print_max_users():
    print(f"Maximum users: {MAX_USERS}")

print_max_users()  # Output: Maximum users: 100

5.4 Managing Variables Without Using global

Using Function Arguments and Return Values

def increment(value):
    return value + 1

counter = 0
counter = increment(counter)  # Assign the function's return value
print(counter)  # Output: 1

5.5 Summary of Using Global and Local Variables

6. Nested Functions and nonlocal Keyword

6.1 What is a Nested Function?

Example of a Nested Function

def outer_function():
    def inner_function():
        print("This is the inner function")

    inner_function()  # Call the inner function from the outer function

outer_function()  # Output: This is the inner function

6.2 Modifying an Outer Function’s Variable Using nonlocal

Example that Raises an Error

def outer_function():
    count = 0  # Variable in the outer function

    def inner_function():
        count += 1  # Error occurs
        print(count)

    inner_function()

outer_function()

Solution: Use the nonlocal Keyword

def outer_function():
    count = 0  # Variable in the outer function

    def inner_function():
        nonlocal count  # Referencing the outer function's variable
        count += 1
        print(count)

    inner_function()
    print(count)  # The count modified inside `inner_function` is reflected

outer_function()

Output

1
1

6.3 Differences Between global and nonlocal

Example Using global

count = 0  # Global variable

def increment():
    global count  # Modify the global variable
    count += 1

increment()
print(count)  # Output: 1

Example Using nonlocal

def outer():
    count = 0  # Variable in the enclosing scope

    def inner():
        nonlocal count  # Modify the outer function's variable
        count += 1

    inner()
    print(count)  # Output: 1

outer()

7. Common Scope-Related Errors and Their Solutions

7.1 UnboundLocalError: Assigning Before Variable Reference

Error Example

count = 0  # global variable

def increment():
    count += 1  # error occurs here
    print(count)

increment()

Error Details

UnboundLocalError: local variable 'count' referenced before assignment

Solution ①: Use the global Keyword

count = 0  # global variable

def increment():
    global count  # explicitly declare global variable
    count += 1
    print(count)

increment()  # output: 1

Solution ②: Use Function Arguments

def increment(count):
    return count + 1

count = 0
count = increment(count)
print(count)  # output: 1

7.2 NameError: Variable Not Defined

Error Example

def print_message():
    print(message)  # error occurs here

print_message()

Error Details

NameError: name 'message' is not defined

Solution

def print_message(message):
    print(message)

print_message("Hello")  # output: Hello

7.3 TypeError: Variable Named Same as Built-in Function

Error Example

sum = 100  # variable with the same name as built-in function `sum()`

print(sum([1, 2, 3]))  # error occurs here

Error Details

TypeError: 'int' object is not callable

Solution

1. Rename the Variable

total = 100  # use `total` instead of `sum`
print(sum([1, 2, 3]))  # works correctly

2. If you have overwritten a built-in function, delete it

sum = 100
del sum  # undo the overwrite

print(sum([1, 2, 3]))  # works correctly

7.4 Best Practices for Preventing Scope-Related Errors

8. Tips for Proper Scope Management

8.1 Minimize Global Variables

Bad Example (Abuse of Global Variables)

counter = 0  # Global variable

def increment():
    global counter  # Modify global variable
    counter += 1

increment()
print(counter)  # Output: 1

Good Example (Using Function Arguments and Return Values)

def increment(value):
    return value + 1

counter = 0
counter = increment(counter)
print(counter)  # Output: 1

8.2 Clarify Function Scope

Good Example (Leveraging Local Scope)

def calculate_square(number):
    result = number ** 2  # Local variable
    return result

print(calculate_square(4))  # Output: 16

8.3 global and nonlocal Proper Use

Use Cases for global

• When managing configuration values or constants
• Variables that hold state (e.g., singleton pattern)

MAX_USERS = 100  # Global variable (treated as constant)

def get_max_users():
    return MAX_USERS

print(get_max_users())  # Output: 100

Use Cases for nonlocal

• When modifying an outer variable inside a nested function

def outer():
    count = 0  # Variable of the outer function

    def inner():
        nonlocal count  # Modify outer variable
        count += 1
        print(count)

    inner()

outer()  # Output: 1

8.4 Checklist for Scope Management

9. FAQ (Frequently Asked Questions and Answers)

9.1 How can you manage global variables without using global?

A: By using function arguments and return values, you can avoid modifying global variables.

def increment(value):
    return value + 1

count = 10
count = increment(count)
print(count)  # Output: 11

9.2 What is the difference between nonlocal and global?

A: nonlocal is used to modify variables in the enclosingh4>

Example of nonlocal

def outer():
    count = 0  # Variable of the outer function

    def inner():
        nonlocal count  # Modify the outer variable
        count += 1

    inner()
    print(count)  # Output: 1

outer()

9.3 What is the LEGB rule?

A: It is a rule that defines the order in which variables are looked up.

1. L (Local): Variables defined inside a function
2. E (Enclosing): Variables from the outer function of a nested function
3. G (Global): Variables in the global scope
4. B (Built-in): Python’s built-in functions

Example of the LEGB rule

x = "global variable"  # G

def outer():
    x = "enclosing variable"  # E

    def inner():
        x = "local variable"  # L
        print(x)  # According to the LEGB rule, refers to the innermost x

    inner()

outer()
print(x)  # Refers to the global variable

10. Summary

10.1 Basics of Python Scope

• The rule that determines the region where a variable can be accessed.
• Local scope (inside functions) and global scope (outside functions) are the basics.

• Prevent unintended overwriting of variables.
• Avoid errors where a variable is not found (such as NameError).
• Improve code readability and make debugging easier.

10.2 Types of Python Scopes

10.3 Proper Use of global and nonlocal

• When managing constants or configuration values
• When multiple functions need to share a common variable

• When you need to modify a variable from an outer function inside a nested function

10.4 Best Practices for Scope Management

10.5 Final Thoughts

10. Summary

10.1 Basics of Python Scope

• The rule that determines the region where a variable can be accessed.
• Local scope (inside functions) and global scope (outside functions) are the basics.

• Prevent unintended overwriting of variables.
• Avoid errors where a variable is not found (such as NameError).
• Improve code readability and make debugging easier.

10.2 Types of Python Scopes

10.3 Proper Use of global and nonlocal

• When managing constants or configuration values
• When multiple functions need to share a common variable

• When you need to modify a variable from an outer function inside a nested function

10.4 Best Practices for Scope Management

10.5 Final Thoughts