What are the 4 scopes in Python?

Michael 158 Published: 09/29/2024

What are the 4 scopes in Python?

I'm happy to respond in English for you!

The 4 scopes in Python refer to the visibility of variables and their values within a program. Understanding these scopes is crucial to writing efficient, readable, and maintainable code.

1. Local Scope

A variable with local scope is defined inside a function or method and is only accessible within that specific function or method. Variables declared within a local scope are not accessible outside the function, unless they're explicitly returned as values. When a function returns, all its local variables are discarded.

Example:

def my_function():

x = 5  # Local variable with local scope


my_function()


print(x)  # Raises a NameError: name 'x' is not defined

In this example, the x variable is only accessible within the my_function() function. Attempting to access it outside the function will raise a NameError.

2. Enclosing Scope

An enclosing scope, also known as a nonlocal scope, is when a function is nested inside another function or method. The inner function has access to variables declared in the outer function. However, this access is not inheritance-based; instead, it's about the physical nesting of scopes.

Example:

def outer_function():

x = 10


def inner_function():


print(x)  # Accessible due to enclosing scope


inner_function()

In this example, the inner_function() has access to the x variable declared in the outer_function(), because it's physically nested within the outer function.

3. Global Scope

A variable with global scope is defined outside any functions or methods and is accessible anywhere in the program. Global variables are created when the program starts, and their values persist until the program terminates.

Example:

x = 20  # Global variable

def my_function():


print(x)  # Accessible due to global scope


my_function()


print(x)

In this example, the x variable is declared outside any functions or methods. It's accessible within the my_function() function and remains accessible throughout the program.

4. Module Scope

A module scope refers to variables defined at the top level of a Python module (a .py file). These variables are essentially global, but they're only accessible within that specific module.

Example:

# my_module.py

x = 30  # Top-level variable with module scope


def my_function():


print(x)


if name == "main":


my_function()

In this example, the x variable is defined at the top level of a Python module (my_module.py). It's accessible within that module and is essentially global.

These four scopes are fundamental to understanding how variables interact with each other in Python. Mastering these concepts will help you write robust, maintainable code that's easy to reason about.

What are local functions in Python?

I'm afraid I must comply with the "rules" .

Local functions in Python refer to functions that are defined within another function, often called a closure. These inner functions have access to variables and parameters of their outer scope, including those declared in the outer function's parameter list.

When an outer function is executed, it creates its own local scope, which includes any variables or functions defined within it. This local scope is destroyed when the outer function completes execution. However, any local functions defined within the outer scope can be returned as values from that function and still retain access to their original scope's variables.

Here are some key characteristics of local functions in Python:

Encapsulation: Local functions provide a way to encapsulate complex logic or utility functions within a larger program without exposing them directly to the global scope. Scope: As mentioned earlier, local functions have access to variables and parameters of their outer scope. This allows them to utilize data from the outer function's context. Closures: When an outer function returns a local function as a value, it creates a closure – a reference to the outer function's scope that persists even after the outer function has completed execution. The inner function can still access and modify variables in its original scope through this closure. Recursion: Local functions can be used recursively to solve problems that require repeated application of an operation or to traverse complex data structures.

To illustrate local functions, consider a simple example:

def outer_function(x):

def inner_function(y):


return x + y


return inner_function


fn = outer_function(5)  # returns the inner function with access to x=5


result = fn(3)          # returns 8 (x + 3)


print(result)           # prints: 8

In this example, outer_function defines a local function (inner_function) that has access to its own parameter x. When we return the inner function from outer_function, it retains access to x even after outer_function has completed execution. The returned inner function can then be called and used as intended.

Local functions are an essential tool for creating reusable, self-contained logic within larger programs in Python. They offer a flexible way to organize code and provide a means of encapsulating complex functionality while minimizing the risk of polluting the global namespace.

Related Articles