Python Scope Resolution – Understanding LEGB Rule (Local, Enclosing, Global, Built-in)

In this article, we'll take a look at Hide

6) Practical Example with Function Definitions:

The LEGB rule in Python is a scoping rule used to determine the order in which namespaces are looked up when a variable name is referenced. In programming, the scope of a name defines the area of a program in which you can unambiguously access that name, such as variables, functions, objects, and so on. A name will only be visible to and accessible by the code in its scope.

Several programming languages take advantage of scope to avoid name collisions and unpredictable behaviors. Python Scope Resolution – LEGB stands for Local, Enclosing, Global, and Built-in, representing the four levels of scope hierarchy. Let’s break down each scope in the LEGB rule and how it applies to Python. First, see the example to illustrate the LEGB rule:

global_var = "global"

def outer():
      enclosing_var = "enclosing"

      def inner():
            local_var = "local"
            print(local_var) # Local scope
            print(enclosing_var) # Enclosing scope
            print(global_var) # Global scope
            print(len) # Built-in scope

      inner()

outer()


Explanation:
In this example:

Inner function print: When inner_function tries to print x, it doesn't find x in its local scope, so it looks in the enclosing scope and prints "enclosing".
Outer function print: When outer_function prints x, it prints "enclosing" because it finds x in its local scope (which is the enclosing scope for inner_function).
Global print: The global print statement prints "global" because it uses the global scope.

global_var = "global"

def outer():

enclosing_var = "enclosing"

def inner():

local_var = "local"

print(local_var) # Local scope

print(enclosing_var) # Enclosing scope

print(global_var) # Global scope

print(len) # Built-in scope

inner()

outer()

Explanation:

In this example:

Inner function print: When inner_function tries to print x, it doesn't find x in its local scope, so it looks in the enclosing scope and prints "enclosing".

Outer function print: When outer_function prints x, it prints "enclosing" because it finds x in its local scope (which is the enclosing scope for inner_function).

Global print: The global print statement prints "global" because it uses the global scope.

Effectively using and implementing the LEGB rule in Python can enhance code clarity, maintainability, and functionality. Here’s how to strategically use each level of scope:

Local Scope (L)

Local (L) (also known as function scope) refers to the code block within a Python function or lambda expression. It contains the names defined inside the function, and these names are only accessible from within the function’s code. A local scope is created each time the function is called, not when it is defined—so each function call, including recursive calls, results in a separate local scope.

def example():
      local_var = "I'm local"
      print(local_var) # This will refer to the local_var inside example()

def example():

local_var = "I'm local"

print(local_var) # This will refer to the local_var inside example()

Use Cases:

Function-specific Variables: When variables are only needed within a function, keeping them local avoids accidental modification from outside the function.
Encapsulation: Local variables help encapsulate functionality, reducing the risk of side effects.

Example:

def calculate_area(radius):
      pi = 3.14159 # Local variable
      return pi * (radius ** 2)

def calculate_area(radius):

pi = 3.14159 # Local variable

return pi * (radius ** 2)

Enclosing Scope (E)

Enclosing (E) (or nonlocal scope) applies specifically to nested functions. When a function is defined inside another function, the outer function’s scope becomes the enclosing scope for the inner function. This scope includes the names defined in the enclosing function, and those names are accessible within both the inner and outer function bodies.

def outer_function():
      enclosing_var = "I'm in the enclosing scope"
      def inner_function():
            print(enclosing_var) # This will refer to enclosing_var from outer_function
      inner_function()

def outer_function():

enclosing_var = "I'm in the enclosing scope"

def inner_function():

print(enclosing_var) # This will refer to enclosing_var from outer_function

inner_function()

Use Cases:

Nested Functions: Use the enclosing scope to share variables between an outer function and its inner functions without making them global.
Closures: Capture and remember values from enclosing scopes.

Example:

def outer_function(message):
      def inner_function():
            print(message) # Enclosing scope variable
      return inner_function

my_function = outer_function("Hello")
my_function() # Outputs: Hello

def outer_function(message):

def inner_function():

print(message) # Enclosing scope variable

return inner_function

my_function = outer_function("Hello")

my_function() # Outputs: Hello

Global Scope (G)

Global (G) (or module scope) represents the outermost scope in a Python script or module. It includes all names defined at the top level of the code. Names declared in the global scope are accessible throughout the module or script.

global_var = "I'm global"

def example():
      print(global_var) # This will refer to global_var

global_var = "I'm global"

def example():

print(global_var) # This will refer to global_var

Use Cases:

Module-level Constants and Configuration: Variables that are meant to be used across multiple functions or parts of a module.
State Tracking: For managing state that needs to be accessed or modified by various functions.

Example:

config = {
      "setting1": True,
      "setting2": "value"
      }

def use_config():
      global config # Global variable
      if config["setting1"]:
            print(config["setting2"])

use_config()

config = {

"setting1": True,

"setting2": "value"

}

def use_config():

global config # Global variable

if config["setting1"]:

print(config["setting2"])

use_config()

Built-In Scope (B)

Built-in (B) is a special scope that is automatically created by Python when a program is executed or an interactive session is started. It contains all the built-in names provided by Python, such as functions, exceptions, and keywords. These names are accessible from any part of the code without the need for explicit declaration.

def example():
      print(len("example")) # This will refer to the built-in len() function

1 2	def example(): print(len("example")) # This will refer to the built-in len() function

Use Cases:

Using Built-in Functions: Make use of Python’s built-in functions like len(), max(), min(), etc., which are available without needing to define them.
Avoid Overriding Built-ins: Be careful not to overwrite built-in names with local or global variables.

Example:

def example_function(data):
      length = len(data) # Built-in len() function
      return length

example_function([1, 2, 3]) # Outputs: 3

def example_function(data):

length = len(data) # Built-in len() function

return length

example_function([1, 2, 3]) # Outputs: 3

Best Practices for Implementing LEGB

Avoid Global Variables When Possible: They can lead to code that is hard to debug and maintain. Use local or enclosing scopes where appropriate.
Use global and nonlocal Keywords Judiciously: Only use these keywords when you have a clear reason to modify a variable in a different scope.
Descriptive Naming: Give local variables descriptive names to avoid confusion and potential conflicts with variables in other scopes.
Limit the Use of Built-ins: Avoid naming your variables with names that conflict with Python’s built-in functions or constants to prevent unexpected behavior.
Encapsulate Code in Functions and Classes: This naturally limits the scope of variables and makes the code modular and reusable.

Example:

# Avoiding conflicts with built-ins by choosing unique variable names
list_of_numbers = [1, 2, 3, 4, 5]

def compute_sum(numbers):
      total = sum(numbers) # Using built-in sum function
      return total

print(compute_sum(list_of_numbers)) # Outputs: 15

# Avoiding conflicts with built-ins by choosing unique variable names

list_of_numbers = [1, 2, 3, 4, 5]

def compute_sum(numbers):

total = sum(numbers) # Using built-in sum function

return total

print(compute_sum(list_of_numbers)) # Outputs: 15

By adhering to these practices, you can leverage the LEGB rule effectively to write clean, efficient, and maintainable Python code.

Practical Example with Function Definitions:

Let’s demonstrate a practical example where the LEGB rule impacts variable resolution in nested functions:

# Global variable
name = "Alice"

def greet():
      # Enclosing variable
      name = "Bob"

      def say_hello():
            # Local variable
            name = "Charlie"
            print("Hello,", name) # Local scope variable 'name' is used here

      say_hello() # Output will be "Hello, Charlie"
      print("Greeting,", name) # Enclosing scope variable 'name' is used here

greet()
print("Global,", name) # Global scope variable 'name' is used here

# Global variable

name = "Alice"

def greet():

# Enclosing variable

name = "Bob"

def say_hello():

# Local variable

name = "Charlie"

print("Hello,", name) # Local scope variable 'name' is used here

say_hello() # Output will be "Hello, Charlie"

print("Greeting,", name) # Enclosing scope variable 'name' is used here

greet()

print("Global,", name) # Global scope variable 'name' is used here

Conclusion:

Understanding the LEGB rule helps in writing clean, readable, and bug-free code by being aware of where and how variables are being accessed and modified. This is especially important in larger programs with multiple nested functions and complex logic.