Some Python Decorators

I've been learning how to use decorators in Python. As far I understand it a decorator takes as input a function, does something with or to the function and then returns the function. To test out this functionality I've written five examples. First the following preamble is included at the top of the file containing the decorator functions:

countit - will print a line to the terminal every time the function is called with the number of times it has been called.

def countit(interceptedFunction): """A decorator that intercepts a function and it's arguments *args and **kwargs and logs the number of times the function has been called to the terminal""" @wraps(interceptedFunction) def counter(*args, **kwargs): counter.called += 1 functionName = interceptedFunction.func_name actualResult = interceptedFunction(*args, **kwargs) logging.debug('\n ###### Function: [{fnc}] => [{count}] ######' .format(fnc=functionName, count=counter.called)) return actualResult counter.called = 0 return counter

timeit - times how long a function takes to run and prints this to the terminal.

def timeit(interceptedFunction): """A decorator that intercepts a function and it's arguments *args and **kwargs times the duration of thefunction and then returns it and logs it to the terminal """ @wraps(interceptedFunction) def timer(*args, **kwargs): functionName = interceptedFunction.func_name start = dt.now() actualResult = interceptedFunction(*args, **kwargs) stop = dt.now() executionTime = stop - start logging.debug('Function: [{fnc}] => Took [{timed}]' .format(fnc=functionName, timed=executionTime)) return actualResult return timer

logit - prints to the the terminal the output that is returned from a function.

def logit(interceptedFunction): """A decorator that intercepts a function and it's arguments *args and **kwargs and logs what the function returns to the terminal as well as the input to the function""" @wraps(interceptedFunction) def logger(*args, **kwargs): functionName = interceptedFunction.func_name functionArguments = [] if kwargs is not None: for arg in args: functionArguments.append(arg) actualResult = interceptedFunction(*args, **kwargs) logging.debug('Function: [{fnc}] => Returns [{returned}] with input {inp}' .format(fnc=functionName, returned=actualResult, inp=functionArguments)) return actualResult return logger

beforeit - runs a function that is passed as an argument to the decorator before each function call.

def beforeit(inputFunc): """A decorator that intercepts a function and it's arguments *args and **kwargs and calls another function (inputFunc) first """ functionName = inputFunc.func_name def beforeFunc(interceptedFunction): @wraps(interceptedFunction) def before(*args, **kwargs): inputFunc() actualResult = interceptedFunction(*args, **kwargs) return actualResult return before return beforeFunc

afterit - runs a function that is passed as an argument to the decorator after each function call.

def afterit(inputFunc): """A decorator that intercepts a function and it's arguments *args and **kwargs and calls another function (inputFunc) after """ functionName = inputFunc.func_name def afterFunc(interceptedFunction): @wraps(interceptedFunction) def after(*args, **kwargs): actualResult = interceptedFunction(*args, **kwargs) inputFunc() return actualResult return after return afterFunc

Each of these decorators can be used individually or as a group. For example, this is a function that computes prime numbers in a rather inefficient manner by calculating the factors of each number smaller than it (a better method would be to use the seive of Eratosthenes). It has been decorated with the first three functions above. It is then called three times as follows:

import time, random from pythonDecorators import * @logit @timeit @countit def isprime(p): i=2 while i<= p/2: if p%i==0: return False i=i+1 return True for num in (7919, 399941, 1042709): isprime(num)

The output produced is:

###### Function: [isprime] => [1] ###### Function: [isprime] => Took [0:00:00.008360] Function: [isprime] => Returns [True] with input [7919] ###### Function: [isprime] => [2] ###### Function: [isprime] => Took [0:00:00.120358] Function: [isprime] => Returns [True] with input [399941] ###### Function: [isprime] => [3] ###### Function: [isprime] => Took [0:00:00.251844] Function: [isprime] => Returns [True] with input [1042709]

So whenever I am writing a new python programme I can now import my decorators file and I will have access to the timeit, countit and logit beforit and afterit decorators to aid in debugging.

If you can think of any other useful applications for decorators please let me know in the comments.

jpowcode

Some Python Decorators

Comments

Pages

Categories

Tags