Create Your Resume
Back to Python
Lesson 23 of 27

What Are Decorators and Closures in Python? Decorator Chaining, Lexical Scoping

Decorators and closures are two of the most powerful yet misunderstood features in Python. They allow developers to modify behavior, preserve state, and build clean, reusable abstractions without changing existing code. Understanding these concepts is essential for writing advanced, Pythonic applications and for working with frameworks, libraries, and production-grade systems. This in-depth guide explains decorators and closures in Python from the ground up. It starts by clearly explaining what closures are, how lexical scoping works, and why Python can “remember” variables even after a function has finished executing. You’ll then learn how decorators are built on top of closures, how they intercept function calls, and how they are used to implement logging, authentication, caching, validation, and performance monitoring in real applications. The article also covers decorator chaining in detail, showing how multiple decorators interact, how execution order works, and what common mistakes developers make. Throughout the guide, you’ll find short but meaningful code examples, comparison tables, and real-world scenarios that explain not just how these features work, but why Python was designed this way. This content is ideal for developers preparing for interviews, building frameworks, or aiming to write clean, maintainable Python code.

Decorators and Closures in Python: A Deep, Practical Explanation

Decorators and closures are core concepts that separate basic Python usage from advanced, professional-level Python development. They are not just language features; they are design tools that allow developers to write cleaner, more modular, and more expressive code.

Many popular Python frameworks and libraries rely heavily on decorators and closures. Understanding them deeply helps you reason about code behavior, debug complex logic, and design reusable abstractions.

What Is a Closure in Python?

A closure is created when a function remembers variables from its surrounding scope even after that scope has finished executing. In simpler terms, a closure allows a function to carry state with it without using global variables or classes.

Closures exist because Python supports lexical scoping, which means that the scope of a variable is determined by where it is defined in the source code.

Basic Closure Example

def outer_function(message):
    def inner_function():
        print(message)
    return inner_function

fn = outer_function("Hello, world")
fn()

Even though outer_function has finished executing, the inner function still remembers the value of message. This remembered value is what forms the closure.

Lexical Scoping Explained

Lexical scoping means that Python resolves variable names based on their position in the source code, not based on the call stack at runtime.

Python looks for variables in the following order:

  1. Local scope
  2. Enclosing (non-local) scope
  3. Global scope
  4. Built-in scope

Closures rely on the enclosing scope. The inner function keeps a reference to variables defined in the outer function, not copies of their values.

Why Closures Matter

  • Avoid global variables
  • Encapsulate state cleanly
  • Create configurable functions
  • Build decorators and callbacks

Closures vs Classes

Aspect Closures Classes
State storage Captured variables Instance attributes
Boilerplate Minimal More code
Use case Simple stateful behavior Complex objects

Closures are ideal for lightweight state and behavior. Classes are better for complex systems.

What Is a Decorator in Python?

A decorator is a function that modifies the behavior of another function without changing its source code. Decorators are built using closures.

In Python, functions are first-class objects. This means they can be passed as arguments, returned from other functions, and wrapped inside closures.

Decorator Without Syntax Sugar

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

def greet():
    print("Hello")

greet = my_decorator(greet)
greet()

The decorator wraps the original function and adds behavior before and after execution.

Decorator Syntax (@ Symbol)

Python provides the @ syntax as a cleaner way to apply decorators. 

@my_decorator
def greet():
    print("Hello")

This syntax is purely syntactic sugar. Internally, Python performs the same reassignment as shown in the previous example.

Real-World Use Cases of Decorators

1. Logging

def log_execution(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

2. Authentication and Authorization

Web frameworks use decorators to protect routes and enforce permissions.

3. Performance Monitoring

Decorators are commonly used to measure execution time and performance bottlenecks.

4. Caching

Decorators can store and reuse results of expensive function calls.

Decorator Chaining Explained

Decorator chaining allows multiple decorators to be applied to a single function. Each decorator wraps the result of the previous one. 

@decorator_one
@decorator_two
def process():
    pass

This is equivalent to: 

process = decorator_one(decorator_two(process))

Execution Order

  • Decorators are applied from bottom to top
  • Execution flows from top to bottom

Why Order Matters

Changing decorator order can completely change behavior, especially for authentication, caching, or validation logic.

Decorators with Arguments

Some decorators need configuration. This requires an additional level of function nesting. 

def retry(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    pass
        return wrapper
    return decorator

This pattern is common in retry logic, rate limiting, and feature toggles.

Common Mistakes with Decorators and Closures

  • Forgetting to return the wrapper function
  • Losing function metadata (name, docstring)
  • Incorrect argument handling
  • Overusing decorators for complex logic

Using functools.wraps helps preserve metadata.

Closures, Decorators, and Maintainability

When used correctly, closures and decorators reduce duplication and improve readability. When misused, they make code harder to understand and debug.

The key is restraint. Decorators should be small, focused, and predictable. Closures should encapsulate state, not hide complexity.

Final Thoughts

Decorators and closures are fundamental to understanding how Python frameworks, libraries, and advanced features work. They are not required for every problem, but mastering them unlocks a deeper level of Python proficiency.

Once you understand closures and decorator chaining, concepts like middleware, callbacks, dependency injection, and even async frameworks become much clearer.