How Do Python Closures Differ From Nested Functions?

Closures in Python: Unveiling the Mystery

Nested functions are commonly found in Python, prompting questions about their relationship with closures. While they share some characteristics, they are not interchangeable.

Closures are functions that retain access to the outer scope's local variables even after the enclosing function has completed execution. This allows them to utilize those variables later.

Nested Functions vs. Closures

Nested functions, on the other hand, are defined within another function but do not inherit its local variables by default. They become closures only if they reference local variables from the outer scope that would otherwise be out of reach after the enclosing function's completion.

Example of a Closure in Python:

def make_printer(msg):
    def printer():
        print(msg)
    return printer

printer = make_printer('Foo!')
printer()  # Output: Foo!

In this example, the nested function printer refers to the local variable msg from the enclosing function make_printer. When make_printer returns, msg would typically be out of scope, but the closure retains access to it.

The Absence of Closure in Nested Functions that Don't Reference Outer Scope Variables:

If a nested function does not reference any local variables from the outer scope, it is not considered a closure. Instead, it behaves as an ordinary function with its own local variables.

Example of a Non-Closure Nested Function:

def make_printer(msg):
    def printer(msg=msg):
        print(msg)
    return printer

printer = make_printer('Foo!')
printer()  # Output: Foo!

Here, the default value of the msg parameter is used in the nested function printer, ensuring that it has its own local variable independent of the outer scope. Thus, it's not a closure.

The above is the detailed content of How Do Python Closures Differ From Nested Functions?. For more information, please follow other related articles on the PHP Chinese website!