Typical Application and Use Cases for Python Decorators

Question

While recently reading this article on Python decorators, it gave as example the technique of memoization as an application of Python decorators. While I have a working understanding of Python decorators I wish to know of more such effective use cases for decorators, and how do you typically use them in your everyday code.

Answer 1

There are a number of built-in decorators that can be useful, such as classmethod, property, staticmethod, and functools.wrap. It is often handy to write a decorator that logs usage of functions for debugging purposes. There are lots of example decorators on this Python wiki page, though I think at least some of these are more aimed at showing off how flexible Python is than actually providing useful functionality.

Answer 2

Since Python 3 supports type annotations, decorators can be used as a way to check.

def check(f):
    def _f(x):
        if type(x) != f.__annotations__['x']:
            raise TypeError(type(x))
        val = f(x)
        if 'return' in f.__annotations__ and f.__annotations__['return'] != type(val):
            raise TypeError(type(val))
        return val
    return _f

@check
def f(x: int) -> int:
    return x * 2

>>> f(2)
4

>>> f('x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in _f
TypeError: <class 'str'>

Answer 3

You can look at effective use cases for python decorators in the Django web framework auth docs. Clear examples (I personally use on an everyday basis) include the usage of decorators for restricting views to authenticated users, restricting access depending on specific user permissions, etc.

Answer 4

This is a practical example. Take a look at fibonacci's series sum with and without memo.

from functools import wraps
def memo(func): 
    cache = {}
    @wraps(func)
    def wrap(*args):
        if args not in cache: 
            cache[args] = func(*args)
        return cache[args] 
    return wrap

def fib(i):
    if i < 2: return 1
    return fib(i-1) + fib(i-2)

@memo
def fib_memo(i):
    if i < 2: return 1
    return fib_memo(i-1) + fib_memo(i-2)

And now test the speed difference!

>>> print fib(200)
...
>>> print fib_memo(200)
...