Python decorators

Python Decorators
Alex Su

Classification 4/3/2012 Copyright 2009 Trend Micro Inc. 1

Before
• Java Jersey
@GET
@PATH(―/hello‖)
public void hello() {
return ―Hello World‖
}

• Python Bottle
@get('/hello')
def hello():
return "Hello World!‖

Copyright 2009 Trend Micro Inc.

What’s a Decorator?
Decoration is a way to specify management code for functions and classes.
Decorators themselves take the form of callable objects (e.g., functions) that
process other callable objects.

• Function decorators install wrapper objects to intercept later function calls
and process them as needed.
• Class decorators install wrapper objects to intercept later instance creation
calls and process them as required.


Why Decorators?
• Decorators have a very explicit syntax, which makes them easier to spot than
helper function calls that may be arbitrarily far-removed from the subject
functions or classes.
• Decorators are applied once, when the subject function or class is defined;
it’s not necessary to add extra code (which may have to be changed in the
future) at every call to the class or function.
• Because of both of the prior points, decorators make it less likely that a user
of an API will forget to augment a function or class according to API
requirements.


Why Decorators?
def query(): @get('/query')
# parse http request @logging
# logging @authentication
# authenticate user @authorization(―admin‖)
# authorize user permission @cache
# if cache exists, return it. def query():
# get data from DB # get data from DB


Function Decorators


Usage
In terms of code, function decorators automatically map the following syntax:
@decorator
def F(arg):
...
F(99) # Call function

into this equivalent form, where decorator is a one-argument callable object
that returns a callable object with the same number of arguments as F:

def F(arg):
...
F = decorator(F) # Rebind function name to decorator result
F(99) # Essentially calls decorator(F)(99)

Implementation
A decorator itself is a callable that returns a callable.

def decorator(F):
print ‖init decorator"
return F

@decorator
def func():
print "Hello‖

This decorator is invoked at decoration time, and the callable it returns is
invoked when the original function name is later called.


Implementation
the decorator returns a wrapper that retains the original function in an enclosing scope

def decorator(F):
def wrapper(*args):
print ‖run function"
F()
return wrapper

@decorator
def func():
print "Hello"
When the name func is later called, it really invokes the wrapper function
returned by decorator; the wrapper function can then run the original func
because it is still available in an enclosing scope.


Implementation
To do the same with classes, we can overload the call operation and use instance at-
tributes instead of enclosing scopes:

class decorator:
def __init__(self, func): # On @ decoration
self.func = func
print "init decorator‖
def __call__(self, *args): # On wrapped function call
print "run function"
self.func(*args)

@decorator
def func(): # func = decorator(func), then func is passed to __init__
print "Hello‖

func() #call __call__'s *args


Class Decorators


Usage
@decorator # Decorate
class C:
...
x = C(99) # Make an instance

is equivalent to the following—the class is automatically passed to the
decorator function, and the decorator’s result is assigned back to the class
name:

class C:
...
C = decorator(C) # Rebind class name to decorator result
x = C(99) # Essentially calls decorator(C)(99)


Implementation
A decorator itself is a callable that returns a callable.

def decorator(C):
print ‖init decorator"
return C

@decorator
class C:
def __init__(self, x, y):
self.attr = 'spam’


Implementation
the decorator returns a wrapper that retains the original function in an enclosing scope

def decorator(cls):
class Wrapper:
def __init__(self, *args):
self.wrapped = cls(*args)
def __getattr__(self, name):
return getattr(self.wrapped, name)
return Wrapper

@decorator
class C:
def __init__(self, x, y):
self.attr = 'spam’

It does support multiple instances, because each instance creation call makes a new
independent wrapper object.


Implementation - invalid
class Decorator:
def __init__(self, C): # On @ decoration
self.C = C
def __call__(self, *args): # On instance creation
self.wrapped = self.C(*args)
return self
def __getattr__(self, attrname): # On atrribute fetch
return getattr(self.wrapped, attrname)
@decorator
class C:
….

x = C()
y = C() # Overwrites x!

this version fails to handle multiple instances of a given class—each instance
creation call overwrites the prior saved instance.


Decorator Nesting


Usage
Sometimes one decorator isn’t enough. To support multiple steps of augmentation,
decorator syntax allows you to add multiple layers of wrapper logic to a decorated
function or method. When this feature is used, each decorator must appear on a line of
its own. Decorator syntax of this form:

@A
@B
@C
def f(...):
...
runs the same as the following:

def f(...):
...
f = A(B(C(f)))


Implementation
def sidedish1(meal):
return lambda: meal() + 30

def sidedish2(meal):

@sidedish1
@sidedish2
def friedchicken():
return 49.0

is equivalent to

friedchicken = sidedish1(sidedish2(friedchicken))

print(friedchicken()) # 119.0

Decorator Arguments


Usage
Both function and class decorators can also seem to take arguments, although really
these arguments are passed to a callable that in effect returns the decorator, which in
turn returns a callable. The following, for instance:

@decorator(A, B)
def F(arg):
...
F(99)
is automatically mapped into this equivalent form, where decorator is a callable that
returns the actual decorator. The returned decorator in turn returns the callable run later
for calls to the original function name:

def F(arg):
...
F = decorator(A, B)(F) # Rebind F to result of decorator's return value
F(99) # Essentially calls decorator(A, B)(F)(99)


Implementation
def sidedish(number):
return {
1 : lambda meal: (lambda: meal() + 30),
4 : lambda meal: (lambda: meal() + 60)
}.get(number, lambda meal: (lambda: meal()))

@sidedish(2)
@sidedish(3)
def friedchicken():
return 49.0



def sidedish(number):
Implementation def dish1(meal):

@sidedish(2) def dish2(meal):
@sidedish(3) return lambda: meal() + 40
def friedchicken():
return 49.0
def dish3(meal):


def dish4(meal):

def nodish(meal):
return lambda: meal()

return {
1 : dish1,
2 : dish2,
3 : dish3,
4 : dish4
}.get(number, nodish)

Decorators Manage Functions and Classes
def decorate(O):
# Save or augment function or class O
return O

@decorator
def F(): ... # F = decorator(F)

@decorator
class C: ... # C = decorator(C)


Logging example
>>> spam(1, 2, 3)
class tracer:
call 1 to spam
def __init__(self, func):
6
self.calls = 0
>>> spam ('a', 'b', 'c')
self.func = func
call 2 to spam
def __call__(self, *args):
abc
self.calls += 1
>>> spam.calls
print('call %s to %s' % (self.calls, self.func.__name__))
2
self.func(*args)

@tracer
def spam(a, b, c):
print(a + b + c)


State Information


Class instance attributes
>>>spam(1, 2, 3)
class tracer:
call 1 to spam
self.calls = 0 6
self.func = func >>>spam(a=4, b=5, c=6)
def __call__(self, *args, **kwargs): call 2 to spam
self.calls += 1 15
>>>eggs(2, 16)
return self.func(*args, **kwargs)
call 1 to eggs

@tracer
65536
def spam(a, b, c): >>>eggs(4, y=4)
print(a + b + c) call 2 to eggs
256
@tracer
def eggs(x, y):
print(x ** y)

Enclosing scopes and nonlocals
>>>spam(1, 2, 3)
def tracer(func):
call 1 to spam
calls = 0
6
def wrapper(*args, **kwargs):
>>>spam(a=4, b=5, c=6)
nonlocal calls
call 2 to spam
calls += 1
15
print('call %s to %s' % (calls, func.__name__))
>>>eggs(2, 16)
return func(*args, **kwargs)
call 1 to eggs
return wrapper
65536
>>>eggs(4, y=4)
call 2 to eggs
256


Enclosing scopes and globals
calls = 0 >>>spam(1, 2, 3)
def tracer(func): call 1 to spam
def wrapper(*args, **kwargs): 6
global calls >>>spam(a=4, b=5, c=6)
calls += 1 call 2 to spam
print('call %s to %s' % (calls, func.__name__)) 15
return func(*args, **kwargs) >>>eggs(2, 16)
return wrapper call 3 to eggs
65536
>>>eggs(4, y=4)
call 4 to eggs
256


Decorating Class Methods


Class Blunders I - Decorating Class Methods
class tracer:
self.calls = 0
self.func = func
def __call__(self, *args, **kwargs):
self.calls += 1
return self.func(*args, **kwargs)


Class Blunders I - Decorating Class Methods
class Person:
def __init__(self, name, pay):
self.name = name
self.pay = pay
@tracer
def giveRaise(self, percent):
self.pay *= (1.0 + percent)
@tracer
def lastName(self):
return self.name.split()[-1]

bob = Person('Bob Smith', 50000)
bob.giveRaise(.25) ## Runs tracer.__call__(???, .25)

The root of the problem here is in the self argument of the tracer class’s __call__ method,
is it a tracer instance or a Person instance?


Using nested functions to decorate methods
def tracer(func):
calls = 0
def onCall(*args, **kwargs):
nonlocal calls
calls += 1
print('call %s to %s' % (calls, func.__name__))
return func(*args, **kwargs)
return onCall


Singleton Classes
instances = {}
def getInstance(aClass, *args):
if aClass not in instances:
instances[aClass] = aClass(*args)
return instances[aClass]

def singleton(aClass):
def onCall(*args):
return getInstance(aClass, *args)
return onCall

@singleton
class Spam:
def __init__(self, val):
self.attr = val


Why Decorators? (Revisited)
drawbacks:
• Type changes
– As we’ve seen, when wrappers are inserted, a decorated function or class
does not retain its original type—its name is rebound to a wrapper object.

• Extra calls
– A wrapping layer added by decoration incurs the additional performance
cost of an extra call each time the decorated object is invoked


Why Decorators? (Revisited)
benefits:
• Explicit syntax
– Decorators make augmentation explicit and obvious.
• Code maintenance
– Decorators avoid repeated augmentation code at each function or class
call.
• Consistency
– Decorators make it less likely that a programmer will forget to use
required wrapping logic.


Q&A


Python decorators

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Python decorators

Similar to Python decorators (20)

More from Alex Su

More from Alex Su (9)

Recently uploaded

Recently uploaded (20)

Python decorators

Editor's Notes