If a decorator is applied every time the function is called, why not simply add the new functionality to the function itself?

Question

I'm learning to use decorators at the moment but am struggling to wrap my head around their purpose and utility.

I initially thought they provided the convenient option to add extra functionality to an existing function (e.g. func()) without changing its source code, but if the additional functionality is executed whenever func() is called thereafter, then why wouldn't you just save the time/space/complexity and add the new functionality to func() directly?

E.g. Say I wanted to make a function print whenever it is executed, then wouldn't this:

def add(*args):
    out = sum(args)
    print("Function 'add' executed.")
    return out

create the exact same function as below, with far less code/complexity?

def log(func):
    def wrapper(*args, **kwargs):
        out = func(*args, **kwargs)
        print(f"Function '{func.__name__}' executed.")
        return out
    return wrapper

@log
def add(*args):
    return sum(args)

Off the top of my head, the only cases I can think of where the latter could potentially be preferable is if you're importing a generalised decorator to modify a function defined in a separate script, or are applying the same func to many functions so are saving space by just putting it in its own function (in which case it would seem more reasonable to just write a regular old function to simply execute it normally inside others).

EDIT

Perhaps a better way to formulate this question: Which of the following is preferable, and why?

def logger():
    # New functionality here
    return

def func1(*args):
    # func1 functionality
    logger()
    return

def func2(*args):
    # func2 functionality
    logger()
    return

Or

def logger(func):
    def wrapper(*args, **kwargs):
        out = func(*args, **kwargs)
        # New functionality here
        return out
    return wrapper

@logger
def func1(*args):
    # func1 functionality
    return

@logger
def func2(*args):
    # func2 functionality
    return

Answer 1

It promotes code reuse and separation of concerns.

To take your argument to the logical extreme, why use functions at all? Why not just have one giant main? A decorator is just a higher-order function and provides a lot of the same benefits that "traditional" functions do; they just solve a slightly different set of problems.

In your example, what if you wanted to change your log implementation to use the logging package instead of print? You would have to find every single function where you copy-pasted the logging behavior to change each implementation. Changing a single decorator's implementation would save you a lot of time making changes (and fixing bugs that arise from making those changes).

Decorators are typically used for behavior (in the decorator function) that wraps or modifies another set of behavior (in the decorated function). Some concrete examples could include:

1. Start a timer when the decorated function starts, stop it when the function returns, and log the total runtime.
2. Inspect the function's arguments, mutate some inputs, inject new arguments, or mutate the function's return value (see functools.cache).
3. Catch and handle certain types of exceptions raised from inside the decorated function.
4. Register the current function with some other object as a callback (see Flask).
5. Run the decorated function within a temporary working directory, and clean up the directory when the function returns.

As many others have stated, you can do all of the above without decorators. But all of these cases could be made cleaner and easier to maintain with the help of decorators.

Answer 2

One benefit is minimizing clutter and repetition in your function implementations. Consider:

@log
def add(*args):
    return sum(args)


@log
def mult(*args):
    return math.product(*args)

vs:

def add(*args):
    out = sum(args)
    print("Function add executed.")
    return out


def mult(*args):
    out = math.product(*args)
    print("Function mult executed.")
    return out

and imagine that repetition over, say, a hundred functions in a large codebase.

If you kept the log function and used it without decorator syntax you might have something like:

def _add(*args):
    return sum(args)


def _mult(*args):
    return math.product(*args)


add = log(_add)
mult = log(_mult)

which isn't the worst thing in the world, but it'd be annoying for a reader having to bounce through a level of indirection each time they try to look up a function's implementation.

Answer 3

The most important factor to the benefit of decorators is the DRY code principle

"Do Not Repeat Yourself" as an principle lends itself to creating easy-to-understand, easy-to-write code. Python's decorators are a fantastic example of features that minimise unnecessary code repetition:

Consider the @dataclass decorator. In short, it allows for classes which store only instance attributes to be written easier, as shown in the following example:

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

versus

@dataclass
class Person:
    name: str
    age: int
    gender: str

The important idea about decorators to realise, however, is that creating the @dataclass decorator and writing the second (better) implementation of Person DO INDEED take more time than just writing the first Person implementation.

However, very critically, the difference emerges when you write a second, or third data-oriented class! At this point, by writing the @dataclass decorator, the creation of every single class can be sped up, by removing the boilerplate.

This example generalises to all decorators: writing a @log decorator is slow for one function, but worth it to log 100 different functions.