Variables and Scope in Python Functions: 3 Crucial Tips

Understanding how variable and scope work within Python functions is crucial for writing clean, organized, and error-free code. In Python, the scope of a variable defines where it’s accessible. Mastering this concept will help you avoid unexpected behavior and build more maintainable programs.

1. Local and Global Scope: Understanding the Difference

• Local Variables: Variables defined inside a function are local to that function. They exist only while the function is running and are not accessible from outside.
• Global Variables: Variables defined outside any function are global. They can be accessed from anywhere in your code.

message = "some global data"  # Global variable

def my_function():
    local_var = "local data"   # Local variable
    print(local_var)           # Works fine
    print(message)            # Can access global variable

my_function()
print(local_var)                # NameError: local_var is not defined

2. Viewing Variables with locals() and globals()

Python provides handy functions to inspect the local and global namespaces:

• locals(): Returns a dictionary of all local variables within the current function.
• globals(): Returns a dictionary of all global variables.

def my_function(x, y):
    print(locals())  # Prints a dictionary of local variables
    print(globals()) # Prints a dictionary of global variables

3. Nested Scopes: Functions Within Functions

You can define functions within other functions, creating nested scopes. Inner functions have access to their own local variables and the variables of their enclosing functions. However, they cannot modify the enclosing function’s local variables directly.

def outer_function(x):
    y = 10

    def inner_function(z):
        print(x, y, z)  # Access to x (parameter), y (enclosing), and z (local)

    inner_function(5) 

4. Resolving Conflicts: The LEGB Rule

Python resolves variable lookups using the LEGB rule:

1. Local (L): Looks for the variable in the local scope (current function).
2. Enclosing (E): If not found locally, looks in the enclosing functions (if any).
3. Global (G): If not found in enclosing functions, looks in the global scope.
4. Built-in (B): If not found anywhere else, looks in the built-in namespace (e.g., print, len).

Example:

x = 10  # Global

def my_function():
    x = 5  # Local
    print(x)  # Output: 5 (local x takes precedence)

my_function()
print(x)  # Output: 10 (global x)

Frequently Asked Questions (FAQ)