SoFunction
Updated on 2025-03-04

Rules and applications of scope in Python

In Python programming, Scope refers to the scope in which a variable can be accessed and referenced. Scope is closely related to the life cycle of a variable, determining when a variable is created, when it is destroyed, and where it can be used. Understanding scope is essential for writing clear, maintainable code.

The scope mechanism in Python can be understood through LEGB rules (Local, Enclosing, Global, Built-in). When we reference a variable in our code, Python will follow this rule to find the scope of the variable layer by layer until the variable is found or an error is thrown.

1. Local Scope

Local scope refers to variables defined inside a function, which can only be accessed and operated within the function. The local scope is temporary. After the function is executed, the variables in the local scope will be destroyed.

For example:

def calculate_square():
    side_length = 5  # Local variables    print(side_length ** 2)  # Can access local variables, output 25 
calculate_square()
# print(side_length) # This raises NameError because side_length is a local variable

In the above code, side_length is a local variable that can only be accessed inside the calculate_square function. Python throws a NameError when an external function attempts to access it because the local variable is beyond its scope.

2. Enclosing Scope

Nested scope refers to the definition of another function within one function. Internal functions can access variables of external functions, while external functions cannot access variables of internal functions. This scope generally occurs in closures.

example:

def outer_function():
    outer_var = 10  # Variables in external functions    
    def inner_function():
        print(outer_var)  # Internal functions can access variables of external functions    inner_function()
 
outer_function()

In the above example, inner_function can access the variable outer_var defined in outer_function. This situation shows that the scope of the inner function can access the variables of the outer function, while the outer function cannot access the variables of the inner function.

3. Global Scope

Global scope refers to variables defined outside the function. Global variables can be accessed and modified anywhere in the program unless the global variable is overwritten with the same variable name in a local scope or nested scope.

global_var = 30  # Global variables 
def print_global():
    print(global_var)  # You can access global variables, output 30 
print_global()
print(global_var)  # can also be accessed in the global scope, output 30

In this example, global_var is a global variable that can be used both in the global scope or inside the function print_global.

4. Built-in Scope

The built-in scope includes some built-in names and functions provided by Python, such as print(), len(), str(), etc. These names are first looked up before other scopes. It should be noted that if we define variables or functions with the same name as the built-in function, these built-in names may be overwritten.

len = 10  # Redefined built-in function len 
print(len)  # Output 10, not the original len function

In the above code, we redefine the built-in len function as an integer 10, which causes subsequent calls to len() to return 10 instead of the original len function.

5. LEGB rules

Python's scope follows LEGB rules, i.e.:

  • Local: First look for the local scope, with the highest priority.
  • Enclosing: If the local scope is not found, then look for any nested scope of outer functions.
  • Global: If it is not found in the nested scope, find the global scope.
  • Built-in: Finally, look for the built-in scope.

Python checks these scopes in sequence until the variables are found. If the variable is not found in all scopes, Python throws a NameError exception.

For example, the following code shows the practical application of LEGB rules:

x = 5  # Global scope 
def outer_function():
    x = 10  # variables of outer function    
    def inner_function():
        x = 15  # variables of internal functions        print(x)  # The access is the x of the internal function, and the output is 15    
    inner_function()
 
outer_function()

In this example, inner_function will first look for the x variable in its local scope, if not found, look for the scope of the external function outer_function and finally look for the global scope. Since x is defined in inner_function, it uses the local variable.

6. Summary

Scope is an important aspect of the variable life cycle in a program. Understanding Python's scope rules helps avoid naming conflicts and improve code readability and maintainability. In actual programming, the rational use of local, nested, global and built-in scopes can help developers manage the scope and life cycle of variables more efficiently.

By mastering LEGB rules, we can have a clearer understanding of Python's priorities when looking for variables, thus avoiding some potential errors and writing more stable code.

This is the article about the rules and applications of scopes in Python. For more related Python scope content, please search for my previous articles or continue browsing the related articles below. I hope you will support me in the future!