Summary  
This chapter covers closures: nested functions that capture and remember variables from their enclosing scope, enabling them to maintain state across multiple calls without using global variables.  

General domain of usage  
Function factories for generating customized, stateful functions.

Watch this video for a step-by-step visual explanation of closures and nested functions in Python. You'll see how closures capture variables from their enclosing scope and how this lets them maintain state across function calls. Examples will demonstrate the difference between a simple nested function and a closure, helping you understand when and why to use closures in your own code.

## Closures vs. Nested Functions

A **nested function** is any function that you define inside another function. Nested functions are useful for organizing code and limiting the scope of helper functions. However, not all nested functions are closures.

A **closure** is a special type of nested function. Closures are nested functions that "remember" and can access variables from their enclosing function's scope, even after the outer function has finished running. This means closures can maintain state across multiple calls.

**Key points:**
- All closures are nested functions;
- Not all nested functions are closures;
- A nested function becomes a closure only if it uses variables from the outer function's scope and those variables are still accessible after the outer function has returned.

This distinction is important for understanding how Python manages variable scope and how you can use closures to encapsulate state and behavior together.

def make_greeter(name):
    def greet():
        return f"Hello, {name}!"
    return greet

greeter = make_greeter("Alice")
print(greeter())  

another_greeter = make_greeter("Bob")
print(another_greeter())  


When you call `make_greeter("Alice")`, Python creates a new `greet` function that remembers the value of `name` as "Alice". Even though `make_greeter` finishes running, the returned `greet` function still has access to the `name` variable from its original scope. This is why calling `greeter()` prints `Hello, Alice!`, and calling `another_greeter()` prints `Hello, Bob!`. Each closure keeps its own copy of the variables it needs.

In this course, you will learn advanced topics such as function arguments, iterators, generators, closures, and decorators. Dozens of practice exercises will help you grasp these topics.

Explore the art of packing and unpacking lists, tuples, and dictionaries to write more expressive and efficient Python code.

Delve into the world of higher-order functions, passing functions as arguments, and writing concise anonymous functions with lambda.

Unravel the mysteries of variable scope, and learn how nested functions and closures enable powerful encapsulation.

Delve into Python's iteration protocol, custom iterators, and generator functions for efficient data processing.