DecoratorDemo


Demonstration of Decorators:

(Adapted from Jon Jacky's Intro to Python class)

Creating a function in a function....


In [1]:
def addn(n):
    def adder(i):
        return i + n
    return adder

NOTE: you oculd use lambda for something as simple as this...


In [2]:
add2 = addn(2)

In [3]:
add2 (1)


Out[3]:
3

In [4]:
add3 = addn(3)

In [5]:
add3(1)


Out[5]:
4

A function that takes a function as an argument, and returns a function can be a decorator.

It usually creates a function inside its scope...

Pass a function as an argument, use that to define the function you return.

(first a couple functions to use...)


In [6]:
def odd(i):
    return i%2
def even(i):
    return not odd(i)

And write a wrapper for them....


In [8]:
def sieve(f):
    def siever(s):
        return [x for x in s if f(x)]
    return siever

Make a couple of sieves:


In [9]:
oddsieve = sieve(odd)
evensieve = sieve(even)

And try them out:


In [10]:
s = range(10)
s


Out[10]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]:
oddsieve(s)


Out[11]:
[1, 3, 5, 7, 9]

In [12]:
evensieve(s)


Out[12]:
[0, 2, 4, 6, 8]

The decorator operator @ abbreviates the preceding pattern

@f def g means

g = f(g)


In [13]:
@sieve
def osieve(i):
    return i % 2

@sieve
def esieve(i):
    return not (i % 2)

In [16]:
osieve(s)


Out[16]:
[1, 3, 5, 7, 9]

In [17]:
esieve(s)


Out[17]:
[0, 2, 4, 6, 8]

A callable class can be used as a function, so you can also use a class as a decorator

(classes and objects are callable (via __init__ and __call__))


In [18]:
class Memoize:
    """
    memoize decorator from avinash.vora
    http://avinashv.net/2008/04/python-decorators-syntactic-sugar/
    """
    def __init__(self, function):  # runs when memoize class is called
        self.function = function
        self.memoized = {}

    def __call__(self, *args):  # runs when memoize instance is called
        try:
            return self.memoized[args]
        except KeyError:
            self.memoized[args] = self.function(*args)
            return self.memoized[args]

To use it -- the nifty decorator syntax:


In [19]:
@Memoize        # same effect as sum2x = memoize(sum2x)
def sum2x(n):
    return sum(2 * i for i in xrange(n))  # takes time when n > 10 million

call it:


In [20]:
sum2x(10)


Out[20]:
90

In [21]:
sum2x(10)


Out[21]:
90

But slow if you call it with a big number:


In [22]:
import time
start = time.clock()
sum2x(10000000)
print "it took %f seconds to run"%(time.clock() - start)


it took 0.968653 seconds to run

But the second time...


In [23]:
import time
start = time.clock()
sum2x(10000000)
print "it took %f seconds to run"%(time.clock() - start)


it took 0.000184 seconds to run

Quiz time: what type of object is sum2x ?


In [24]:
repr(sum2x)


Out[24]:
'<__main__.Memoize instance at 0x102f80488>'

In [ ]: