Decorators in Python

Table of Contents

What are Decorators
#

A decorator is a callable that takes another function as argument and returns a new function as output. It’s used in the following way:

@logthis
def perform_action(n):
....
....

Decorators come under Metaprogramming i.e changing program behaviour at runtime.

Example
#

Decorators are executed right after the decorated function is defined. That is usually at import time. The following decorator is used to find the execution time of a function

import time
from functools import wraps

def timeit(func):
  """
  Reports the execution time
  """
  @wraps(func)
  def wrapper(*args,**kwargs):
    start = time.time()
    result = func(*args,**kwargs)
    end = time.time()
    print(func__name__,end - start)
    return result
  
  return wrapper

Example of using this decorator

@timeit
def exponentiation(b,n):
  exp_iter(b, n, 1)
  

def exp_iter(b,counter,product):
  if counter == 0:
      print(product)
  else:
      counter = counter - 1
      product = b * product
      exp_iter(b,counter,product)

and the output will be

16
exponentiation 0.00020766258239746094

The use of wraps(func)in the above code is there to preserve function metadata.This will help us in getting function metadata like:

exponentiation.__name__
exponentiation.__doc__

Defining a decorator that takes arguments
#

You can also define decorators that can accept arguments.For example let us take a decorator that adds logging to a function and allows the user to specify the loggin details:

from functools import wraps
import logging

def logger(level,name=None,message=None):

    """
    A simple logger decorator that allows the 
    user to specify the logging details like 
    name and message
    """
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getlogger(logname)
        logmessage = message if message else func.__name__

        @wraps(func)
        def wrapper(*args,**kwargs):
            log.log(level,logmsg)
            return func(*args,**kwargs)
        
        return wrapper

    return decorate    

Usage:

@logged(logging.DEBUG)
def add(x,y):
    return x + y

Decorators are definately an useful functionality.There are some advance decorator concepts that I will write about next, these are:

Defining decorators inside classes
Defining decorators as classes

What are Decorators #

Example #

Defining a decorator that takes arguments #

What are Decorators
#

Example
#

Defining a decorator that takes arguments
#