Python Decorators: Explained in What Why When
Tags: python, programming, webdev
Published: 2023-02-12 16:00:00

Decorators are incredibly powerful in Python. They are useful for creating modular and reusable code. Plus, they're pretty cool once you get the hang of them!

In this blog post, we'll take a look at what decorators are, why you should use them, and when you should and shouldn't use them.

As always, I’ll try to explain everything in layman's terms. My goal is to get you comfortable with decorators.

### TL;DR

-   Think of Python decorators as little "wrappers" that you can place around a function (or another object) to modify its behavior in some way.
-   You would typically use decorators for logging, authentication, or to make a function run faster by caching its result.

## What are decorators

Let’s start with a simple explanation of what decorators are in Python.

A decorator is really just a function that takes in a function as an argument. It then returns a modified version of that function.

Here’s a classic example:

```python
def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper
```

-   In this example, the `my_decorator` function takes a function as an argument (which we'll call `func`) and defines a new inner function called `wrapper`.
-   The `wrapper` function prints a message before and after calling the original `func` function.
-   The `my_decorator` function then returns the `wrapper` function.

To use a decorator, we would apply it to a function using the `@` symbol, e.g. `@my_decorator`. Here’s an example:

```python
def my_decorator(func):
    ...

@my_decorator
def greet_ben():
    print("Hello, Ben!")
```

If we were to call `greet_ben`, the output would look like this:

```bash
Before the function is called.
Hello, Ben!
After the function is called.
```

See how we effectively modified `greet_ben` to print additional messages without changing the code of the original function itself?

### Syntactic sugar

You see, the decorator syntax `@my_decorator` is merely syntactic sugar. The 2 following function definitions are semantically equivalent:

```python
def my_decorator(func):
    ...

# Function definition 1
def greet_ben():
    ...
greet_ben = my_decorator(greet_ben)

# Function definition 2
@my_decorator
def greet_ben():
    ...
```

Interesting, right?

### Python decorator template

Now, hold your thought for a second, that was not how we would typically write a decorator function in Python — there are better ways.

Instead, [check out this template](https://gist.github.com/jaantollander/48480cfabbe98a7efe4c9848a5b55e6a) later to learn how to write a generic decorator function.

## Why use decorators

Understanding the “why” is kind of like adding the icing on the cake — it just makes the whole thing a lot sweeter. So why use decorators at all?

Well, decorators provide a flexible and convenient way to add extra functionality to existing functions, making them more _reusable_ and _modular_.

This is useful when you want to add a feature to a function that is used in multiple places in your code, but you don't want to modify the original function itself.

### Avoid cluttering

For example, you might want to add logging or error handling to a function. But, you don't want to clutter the original function with that extra code.

By using a decorator, you can add extra functionality without changing the original function, making your code cleaner and more organized.

## When to use decorators

Now that we know why we should use decorators, let's talk about when to use them.

Generally speaking, Python decorators are most useful when you want to add extra functionality to a function without modifying its code. This might include things like:

1. Logging
2. Error handling
3. [Caching](https://docs.python.org/3/library/functools.html#functools.cache)
4. Authentication ([see example in Flask](https://circleci.com/blog/authentication-decorators-flask/))
5. Timing a function execution ([see an advanced example](https://gist.github.com/Integralist/77d73b2380e4645b564c28c53fae71fb))

### A caching example

Here's an example of how you might implement a simple cache for a Fibonacci function:

```python
cache = {}

def fib(n):
    if n in cache:
        return cache[n]

    if n <= 1:
        return n

    result = fib(n - 1) + fib(n - 2)
    cache[n] = result
    return result

print(fib(100)) # 354224848179261915075
```

Notice that the caching code lives inside the `fib` function itself.

However, with decorators, we can simply define a caching decorator and use it to add caching functionality to our Fibonacci function:

```python
cache = {}

def cache_results(func):
    def wrapper(n):
        if n in cache:
            return cache[n]

        result = func(n)
        cache[n] = result
        return result
    return wrapper

@cache_results
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(100)) # 354224848179261915075
```

-   Here, we've implemented our own simple cache using a dictionary.
-   We've also defined our own decorator function `cache_results` that takes a function as an argument and returns a new function that wraps the original function.
-   This inner function checks the cache to see if a result has already been calculated, and if so, it returns the cached result.
-   Otherwise, it calculates the result and adds it to the cache before returning it.
-   This way, we can apply the `cache_results` decorator to any function we want to add caching for.

While both examples work, the latter allows us to easily add caching to other functions without having to write the caching code inside each function.

This makes the caching code in our example more reusable and modular!

### A better example with built-in modules!

Instead of reinventing the wheel, we can use the `lru_cache` decorator from the `functools` module to add caching to your `fib` function:

```python
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(100)) # 354224848179261915075
```

-   Using `lru_cache` decorator is really easy – all you have to do is add the decorator to your function and it automatically handles the caching for you.
-   So, using `lru_cache` can be a great way to optimize your code without a lot of extra effort.

Again, this is just one example of how you can use decorators to make your code more efficient and elegant.

## When NOT to use decorators

So, when should you avoid using decorators?

Well, decorators are great for keeping your code clean and easy to read, but they can make your code harder to understand if overused or used incorrectly.

In general, it's best to avoid using decorators if they make your code more complex than it needs to be, or if you're not sure how they work.

For instance, if you're working on a very small project and you don't need to keep track of how many times your functions are called, then you probably don't need to use a decorator.

In some cases, you may find that it might be more appropriate to modify the code of the original function directly, rather than using a decorator.

It's always a good idea to keep things simple and easy to understand!

## Summary

In short, Python decorators are like little "wrappers" that you can place around a function (or another object) to modify its behavior in some way.

Decorators are useful for creating modular and reusable code in Python.

You can define a decorator once and then apply it to any number of functions. This allows you to easily add the same extra functionality to multiple functions without repeating yourself.

---

_This article was originally published at [jerrynsh.com](https://jerrynsh.com/python-decorators-explained-in-what-why-when/)_