7 Things I Never Knew About Decorators (Python) Until Recently

Day 77 of experimenting with video content

1) Decorator Syntax Equivalent

I actually never knew about this until the first year of work (5 years into learning Python).

@your_decorator
def test():
  pass

^ this is a function test being decorated by the decorator your_decorator

def test():
  pass

test = your_decorator(test)

^ this is the exact same as the earlier block of code.

2) Advanced decorators

@seomthing('test')
def test():
  pass

^ you’ve probably seen special decorators like this.

def test():
  pass

test = something('test')(test)

^ this is the exact same as the earlier code block.

Here, the function call something('test') itself returns a decorator, which our function test is passed into. So here, something is an advanced decorator which returns a function which returns a function.

def add_symbol(symbol):
  def decorator(func):
    def wrapper(name):
      return func(name) + symbol
    return wrapper
  return decorator

@add_symbol('!')
def greet(name):
  return f'hello {name}'

print(greet('tom'))    # hello tom!

^ an example of an advanced decorator.

3) Classes can be decorators too

Advanced decorators can be a tad confusing with the double nested function. Instead, we can use a class as a decorator such that we do not need to deal with the double nested function.

def add_symbol(symbol):
  def decorator(func):
    def wrapper(name):
      return func(name) + symbol
    return wrapper
  return decorator

^ an advanced decorator

class add_symbol():
    def __init__(self, symbol):
        self.symbol = symbol

    def __call__(self, func):
        def wrapper(name):
            return func(name) + self.symbol
        return wrapper

^ rewriting the advanced decorator add_symbol using a class rather than a function.

And this is possible due to the __call__ magic method, which defines object behaviour when we call the object like we would a function.

4) We can use decorators for admin stuff eg. logging/timing stuff

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(name)s:%(levelname)s:%(asctime)s:%(message)s',
    filename='app.log',
)
logger = logging.getLogger('my_logger')

def log(message):
    def decorator(func):
        def wrapper(*args, **kwargs):
            logger.info(message)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log('apple orange pear')
def greet(name):
    return f'hello {name}'

print(greet('tom'))

Here, whenever we call the greet function, we automatically log the message 'apple orange pear'. We no longer need to manually type logger.info(whatever) every time we call the greet function.

5) @cache

Let’s write a recursive function fib(n) that returns the nth fibonacci number.

The fibonacci number sequence starts with [0, 1], and every subsequent number is the sum of the previous 2 numbers. It goes [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...]

def fib(n):
    if n == 1:
        return 0
    if n == 2:
        return 1
    return fib(n-1) + fib(n-2)

^ here’s a recursive implementation of fib(n). Note that if we call fib(5), we have quite a number of function calls.

f(5) = f(3) + f(4)
     = [f(1) + f(2)] + [f(2) + f(3)]
     = [f(1) + f(2)] + [f(2) + [f(1) + f(2)]]
     = [0+1] + [1 + [0+1]]
     = 3

Here, notice that f(3) is computed twice, which isn’t very efficient. And this problem gets worse the higher our n becomes. Take f(7):

f(7) = f(5) + f(6)
     = [f(3) + f(4)] + [f(4) + f(5)]
     = [f(1) + f(2)] + [f(2) + f(3)] + [f(2) + f(3)] + [f(3) + f(4)]
     = f(1)+f(2)+f(2)+[f(1)+f(2)]+f(2)+[f(1)+f(2)]+[f(1)+f(2)]+[f(2)+f(3)]
     = f(1)+f(2)+f(2)+f(1)+f(2)+f(2)+f(1)+f(2)+f(1)+f(2)+f(2)+[f(1)+f(2)]
     = 0+1+1+0+1+1+0+1+0+1+1+0+1
     = 8

if n goes any higher, i don’t really wanna type it out. But you can see that there are many many repeat computations in this process. But @cache can get rid of these repeat computations.

from functools import cache

@cache
def fib(n):
    if n == 1:
        return 0
    if n == 2:
        return 1
    return fib(n-1) + fib(n-2)

Here, @cache computes and stores each value of n and fib(n) such that each fib(n) is computed only once. For instance, fib(5) is computed only one time, and stored in some store.

And if we need fib(5) again later elsewhere, we do not compute it again. Instead, we simply retrieve its value from the store, thus making things a lot faster as we do not need to recompute stuff again and again.

6) @staticmethod and @classmethod

class Dog:
    all_dog_names = []

    def __init__(self, name, age):
        self.name = name
        self.age = age
        
        self.__class__.all_dog_names.append(name)

    @classmethod
    def get_all_dog_names(cls):
        return cls.all_dog_names

    @staticmethod
    def add(x, y):
        return x + y

rocky = Dog('rocky', 4)
fifi = Dog('fifi', 4)
baaron = Dog('baaron', 4)

print(Dog.get_all_dog_names())

# ['rocky', 'fifi', 'baaron']

Using the built-in classmethod and staticmethod decorators, we can create class methods and static methods.

• class methods belong to the class itself (think Dog rather than rocky) only have access to class attributes, and not instance attributes.
• static methods have access to neither class nor instance attributes.

7) @wraps

def greet(name):
    '''says hello to someone'''
    return f'hello {name}'

print(greet.__name__)  # greet
print(greet.__doc__)   # says hello to someone

^ we can check function metadata using methods like function.__name__ and function.__doc__

def add_exclamation(func):
    def wrapper(name):
        return func(name) + '!'
    return wrapper

@add_exclamation
def greet(name):
    '''says 'hello' to someone'''
    return f'hello {name}'

print(greet.__name__)    # wrapper
print(greet.__doc__)     # None

However, we can decorate our greet function, our metadata becomes messed up. This is because we’re actually doing greet = add_exclamation(greet), and reassigning the variable greet to the wrapper function inside of add_exclamation.

from functools import wraps

def add_exclamation(func):
    @wraps(func)
    def wrapper(name):
        return func(name) + '!'
    return wrapper

@add_exclamation
def greet(name):
    '''says 'hello' to someone'''
    return f'hello {name}'

print(greet.__name__)
print(greet.__doc__)

^ by using @wraps(func), we can stop our function metadata from being screwed up

Here, @wraps helps us to preserve our function’s metadata even when it is being decorated.

Conclusion

Hope this was clear and easy to understand.

Some Final words

If this story was helpful and you wish to show a little support, you could:

1. Clap 50 times for this story
2. Leave a comment telling me what you think
3. Highlight the parts in this story that resonate with you

These actions really really help me out, and are much appreciated!

Ebooks I’ve Written: https://zlliu.co/ebooks

LinkedIn: https://www.linkedin.com/in/zlliu/