Understanding Python Scoping Rules


Python scoping rules determine how variables are accessed and referenced in different parts of the code. Proper understanding of these rules is crucial for writing efficient and bug-free Python programs. In this article, we will explore the scoping rules in Python and clarify the confusion around variable scope in various contexts.

Understanding Variable Scope in Python

Variable scope defines the region of the program where a variable is accessible. In Python, there are mainly three types of variable scopes:

  • Local Scope: Variables declared inside a function or a block are accessible only within that function or block. They are not accessible outside of it.
  • Enclosing Scope: Variables declared in the enclosing block of a nested function are accessible within the nested function. In the example code provided, x would be found in the enclosed block of the for loop.
  • Global Scope: Variables declared outside of any function or block have global scope and can be accessed throughout the program.

Let's understand this with some examples:

Example 1: Local Scope

def foo():
    x = 10
foo()  # Output: 10
print(x)  # Error: NameError: name 'x' is not defined

In this example, the variable x is declared inside the function foo(). It has a local scope and can only be accessed within the function. When we try to access x outside of the function, a NameError is raised.

Example 2: Enclosing Scope

def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20
    inner()  # Output: 10
    print(x)  # Output: 20


In this example, the variable x is declared in the outer() function, which is the enclosing scope for the inner() function. We use the nonlocal keyword to indicate that the variable is not local to inner(), but is found in the enclosing scope. The value of x is initially 10, and when we modify it inside the inner() function, the change is reflected in the outer() function as well.

Example 3: Global Scope

x = 10

def foo():
foo()  # Output: 10
print(x)  # Output: 10

In this example, the variable x is declared outside of any function. It has global scope and can be accessed from anywhere in the program. Both the foo() function and the print statement outside the function can access and modify the value of x.

Context During Execution and Lambda Functions

The scoping rules can become more complex when considering the context during execution and lambda functions. When a function is passed somewhere else or defined as a lambda function, the scoping rules still apply. However, the context in which the function is executed can affect the availability of variables.

Let's consider an example:

def outer():
    x = 10
    return lambda y: x + y

add = outer()
print(add(5))  # Output: 15

In this example, the outer() function returns a lambda function that adds a given value to x. Even though the outer() function has completed its execution and the variable x is no longer in scope, the returned lambda function still remembers the value of x. This is an example of closure in Python.


Understanding the scoping rules in Python is essential for writing correct and efficient code. By following the guidelines provided in this article, you can avoid confusion and easily determine where a variable is found in different contexts. Remember to define variables in the appropriate scope to ensure they are accessible where they are needed. With a solid understanding of variable scope, you can write better Python programs!