In Python, scope refers to the region of a program where a variable is recognized and can be used. Understanding variable scope is crucial because it determines how variables behave and where they can be accessed. The two most common scopes in Python are local and global.

This guide explains the difference between local and global variables, how they interact, and how to use them correctly through simple and practical examples.

1. What is Scope?

Scope defines where a variable is accessible in your code. Python uses the LEGB rule to resolve variable names:

• L - Local
• E - Enclosing
• G - Global
• B - Built-in

2. Local Variables

A local variable is one that is defined inside a function and only exists within that function.

# Example 1: Local variable
def greet():
    message = "Hello from inside the function"
    print(message)

greet()
# print(message)  # Error: message is not defined outside the function

3. Global Variables

A global variable is defined outside of any function and can be accessed anywhere in the program.

# Example 2: Global variable
name = "Riya"  # Global variable

def say_hello():
    print(f"Hello, {name}!")

say_hello()  # Output: Hello, Riya!

4. Variable Name Conflict: Local Overrides Global

If a variable with the same name is defined both globally and locally, the local version takes precedence inside the function.

# Example 3: Local overrides global
value = 10

def show_value():
    value = 5  # Local variable
    print("Inside function:", value)

show_value()        # Output: Inside function: 5
print("Outside function:", value)  # Output: Outside function: 10

5. Modifying Global Variables Inside Functions

To modify a global variable from inside a function, you must declare it as global.

# Example 4: Using global keyword
count = 0

def increment():
    global count
    count += 1

increment()
print("Count:", count)  # Output: Count: 1

6. Avoiding Global Variables

Although global variables are accessible everywhere, relying on them too much can make your code harder to understand and debug. Prefer passing values through parameters when possible.

7. Nested Functions and Enclosing Scope

A function defined inside another function can access variables from the outer function (enclosing scope).

# Example 5: Enclosing scope
def outer():
    greeting = "Hello"

    def inner():
        print(greeting)

    inner()

outer()  # Output: Hello

8. Summary of Scope Types

9. Best Practices

• Avoid unnecessary use of global variables
• Use meaningful variable names to avoid conflicts
• Prefer returning values from functions over modifying global state

10. Final Thoughts

Understanding the difference between local and global scope helps you manage variables effectively and avoid bugs in your code. By writing functions that manage their own state using local variables and limiting global state, you make your code cleaner, safer, and easier to test.