Python Function Decorators: How to Create and Chain Them Together

By the end of this page, you will understand what Python decorators are, how to write simple decorators that wrap a function, and how stacked decorators are applied in order. You will also see how to trace execution step by step, avoid common mistakes, and use decorators in practical code.

Decorators in Python are functions that take another function, extend or modify its behavior, and return a new function.

In this example, the goal is not to change the original say() function directly. Instead, each decorator wraps it with extra behavior:

• make_italic adds <i>...</i> around the returned string
• make_bold adds <b>...</b> around the returned string

A decorator works because functions in Python are first-class objects. That means you can:

• pass functions as arguments
• return functions from other functions
• assign functions to variables

When decorators are stacked, Python applies them from the bottom up.

@make_bold
@make_italic
def say():
    return "Hello"

This is equivalent to:

def say():
    return "Hello"

say = make_bold(make_italic(say))

So the execution flow is:

1. say() returns

Think of a decorator like gift wrapping.

• The original function is the item inside the box.
• One decorator adds one layer of wrapping.
• Another decorator adds another layer around that.

If say() returns Hello, then:

• make_italic wraps it first: <i>Hello</i>
• make_bold wraps the result again: <b><i>Hello</i></b>

So stacked decorators are like nested layers around the original function result.

A basic decorator has this shape:

def my_decorator(func):
    def wrapper():
        return func()
    return wrapper

For your example, you can write:

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper


def make_italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper


@make_bold
@make_italic
def say():
    return "Hello"

print(say())

Output:

<b><i>Hello</i></b>

How it works

• receives and returns a new

Consider this code:

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper


def make_italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper


@make_bold
@make_italic
def say():
    return "Hello"

This is processed like this:

def say():
    return "Hello"

say = make_bold(make_italic(say))

Step-by-step when Python defines say

1. Python creates the original say function.
2. Python applies make_italic(say).
3. make_italic returns its function.

Decorators are often used when you want to add the same behavior to many functions without repeating code.

Formatting output

Your HTML example is a formatting use case:

• wrapping strings in tags
• adding prefixes or suffixes
• converting output to a standard format

Logging

def log_call(func):
    def wrapper():
        print(f"Calling {func.__name__}")
        return func()
    return wrapper

Used for:

• debugging
• auditing
• tracking execution

Authentication and permissions

In web apps, decorators often check whether a user is allowed to run a function.

def require_admin(func):
    def wrapper(user):
        if not user.get("is_admin"):
            return "Access denied"
        return func(user)
    return wrapper

In real projects, decorators are usually written to handle any arguments, not just functions with no parameters.

A common pattern is:

from functools import wraps


def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # extra behavior before
        result = func(*args, **kwargs)
        # extra behavior after
        return result
    return wrapper

Why *args and **kwargs matter

They allow the decorator to work with many different functions:

• functions with positional arguments
• functions with keyword arguments
• functions with optional parameters

Common patterns in real codebases

• Guard clauses: stop execution early if conditions are not met
• Validation: check argument values before calling the function
• Error handling: catch exceptions and return safer output
• Logging: record when a function starts and finishes
• Configuration: apply environment-specific behavior
• Caching: reuse previous results for expensive calls

Example with arguments

1. Forgetting to return the wrapper

Broken code:

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"

Problem:

• The decorator returns None
• The decorated function becomes unusable

Fix:

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper

2. Returning the function instead of calling it

Broken code:

def make_italic(func):
    def wrapper():
        return f"<i>{func}</i>"
    return wrapper

Problem:

Decorator vs calling helper functions manually

Without decorators:

Basic decorator pattern

def decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

String-wrapping decorators

from functools import wraps


def make_bold(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper


def make_italic(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

Stacking order

@a

 ():
    

How do Python decorators work?

A decorator is a function that takes another function, wraps it with extra behavior, and returns the wrapped version.

In what order are stacked decorators applied?

They are applied from the bottom up. @a above @b means a(b(func)).

Why should I use functools.wraps?

It preserves the original function's name, docstring, and other metadata, which helps with debugging and tools.

Can decorators accept function arguments?

Yes. The wrapper should usually use *args and **kwargs so it can pass arguments through.

Can a decorator change the return value?

Yes. In your example, the decorators change the returned string by wrapping it in HTML tags.

Do decorators only work for formatting strings?

No. They are commonly used for logging, validation, caching, permissions, and error handling.

What is the difference between a decorator and a normal function?

A normal function performs a task directly. A decorator modifies or extends another function's behavior.

Can I stack more than two decorators?

Yes. You can stack multiple decorators, and each one wraps the result of the one below it.

• First-class functions — decorators rely on functions being passed around like values.
• Higher-order functions — a decorator is a function that takes and returns functions.
• Nested functions — decorators usually define an inner wrapper function.
• Closures — the wrapper keeps access to the original func.
• functools.wraps — helps preserve function metadata when decorating.
• Function arguments with *args and **kwargs — important for writing decorators that work with many functions.
• Python call stack — useful for understanding how nested wrappers execute.
• Reusable abstraction — decorators let you apply shared behavior cleanly across many functions.