Decorator

By /

A decorator is a design pattern in programming, particularly prominent in languages like Python, that allows you to add new functionality to an existing object or function without altering its structure. Think of it like putting a fancy wrapper around a gift: the gift itself (your original function) remains unchanged, but the wrapper (the decorator) adds extra flair or features, such as logging, authentication, or timing, every time the gift is used.

Why It Matters

Decorators are crucial for writing clean, maintainable, and reusable code. They enable a concept called “separation of concerns,” meaning you can keep different parts of your code (like core logic and supplementary features) distinct. This makes your programs easier to read, debug, and extend. In 2026, with complex AI models and distributed systems, decorators help manage the complexity of adding cross-cutting concerns like performance monitoring or access control to numerous functions without cluttering their main logic. They are a cornerstone of many modern web frameworks and libraries.

How It Works

At its core, a decorator is a function that takes another function as an argument, adds some functionality, and then returns a new function (or the modified original). This wrapping happens at definition time. When you call the decorated function, it’s actually the wrapper function that executes, performing its added tasks before or after calling the original function. The @ symbol in Python is syntactic sugar for this process, making it very elegant to apply. Here’s a simple Python example:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Common Uses

  • Logging: Automatically record when a function is called and with what arguments.
  • Authentication/Authorization: Check if a user has permission to access a specific function.
  • Performance Monitoring: Measure how long a function takes to execute.
  • Caching: Store the results of expensive function calls to avoid recomputing them.
  • Input Validation: Ensure that the arguments passed to a function meet certain criteria.

A Concrete Example

Imagine you’re building a web application using a Python framework like Flask or Django. You have several functions that handle different web pages, and you want to ensure that only logged-in users can access certain pages, like their profile or settings. Instead of adding a manual login check at the beginning of every single function, you can use a decorator.

Let’s say you have a function is_logged_in(user_id) that checks if a user is authenticated. You could create a decorator called @login_required. When a user tries to access a page like /profile, the decorator would first run its check. If the user isn’t logged in, it might redirect them to the login page. If they are, it allows the original profile_page() function to execute. This keeps your profile_page() function focused purely on displaying profile information, without being cluttered by security logic.

from functools import wraps

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        # In a real app, you'd check session/user object
        user_logged_in = False # Simulate not logged in
        if not user_logged_in:
            print("Redirecting to login page...")
            return "Please log in to view this page."
        return f(*args, **kwargs)
    return decorated_function

@login_required
def view_profile(username):
    return f"Welcome, {username}! This is your profile page."

print(view_profile("Alice"))

# If user_logged_in was True, it would print: "Welcome, Alice! This is your profile page."

Where You’ll Encounter It

You’ll frequently encounter decorators in web development frameworks like Flask, Django, and FastAPI for Python, where they are used to define routes, apply middleware, or enforce permissions. Data scientists and machine learning engineers use them for logging model training progress, timing function execution, or memoizing expensive computations. In general programming, any time you see the @ symbol above a function definition in Python, you’re looking at a decorator. Many Python libraries and AI/dev tutorials will leverage decorators to simplify code and add features without modifying core logic.

Related Concepts

Decorators are a form of higher-order function, which is a function that takes one or more functions as arguments or returns a function as its result. They are closely related to the concept of Aspect-Oriented Programming (AOP), which aims to modularize cross-cutting concerns. While decorators are specific to functions, the broader idea of modifying behavior without changing the original object can be seen in design patterns like the Proxy pattern or Adapter pattern. In JavaScript, similar functionality can be achieved using higher-order components (HOCs) in React or through actual decorators (though their implementation details differ from Python‘s).

Common Confusions

A common confusion is mistaking a decorator for simple function composition or a wrapper function that just calls another function. The key distinction is that a decorator modifies the *behavior* of the function it wraps, often adding logic *before* or *after* the wrapped function executes, and it does so in a reusable, declarative way using the @ syntax. It’s not just calling one function inside another; it’s dynamically creating a new function that incorporates the original’s logic plus the decorator’s enhancements. Another point of confusion can be the order of multiple decorators applied to a single function, which execute from bottom to top (closest to the function first).

Bottom Line

Decorators are a powerful and elegant programming construct that allows you to extend or modify the behavior of functions or classes without directly changing their source code. They promote cleaner code by separating concerns, making it easier to add features like logging, authentication, or performance monitoring across multiple parts of your application. Understanding decorators is essential for working with many modern Python frameworks and for writing highly modular and maintainable code in general.

Scroll to Top