Implementing the decorator pattern in Python

It’s arguably not the best practice, but you can add functionality to instances, as I’ve done to help transition my code from Django’s ORM to SQLAlachemy, as follows:

def _save(self):
    session.add(self)
    session.commit()
setattr(Base,'save',_save)

The UML diagram in the linked Wikipedia article is wrong and so is your code.

If you follow the “decorator pattern”, the decorator class is derived from the base decorated class. (In the UML diagram an inheritance arrow from the WindowDecorator to Window is missing).

with

class foo_decorator(foo):

you don’t need to implement undecorated methods.

BTW: In strong typed languages there is one more reason, why the decorator must be derived from the decorated class: Otherwise you wouldnt be able to chain decorators.

As an addendum to Philipp’s answer; if you need to not only decorate, but preserve the type of an object, Python allows you to subclass an instance at runtime:

class foo(object):
    def f1(self):
        print "original f1"

    def f2(self):
        print "original f2"


class foo_decorator(object):
    def __new__(cls, decoratee):
        cls = type('decorated',
                   (foo_decorator, decoratee.__class__),
                   decoratee.__dict__)
        return object.__new__(cls)

    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()


u = foo()
v = foo_decorator(u)
v.f1()
v.f2()
print 'isinstance(v, foo) ==', isinstance(v, foo)

This is a bit more involved than strictly necessary for your example, where you know the class being decorated in advance.

This might suffice:

class foo_decorator(foo):
    def __init__(self, decoratee):
        self.__dict__.update(decoratee.__dict__)

    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()

To complement @Alec Thomas reply. I modified his answer to follow the decorator pattern. This way you don’t need to know the class you’re decorating in advance.

class Decorator(object):
    def __new__(cls, decoratee):
        cls = type('decorated',
                   (cls, decoratee.__class__),
                   decoratee.__dict__)
        return object.__new__(cls)

Then, you can use it as:

class SpecificDecorator(Decorator):
    def f1(self):
        print "decorated f1"
        super(foo_decorator, self).f1()

class Decorated(object):
    def f1(self):
        print "original f1"


d = SpecificDecorator(Decorated())
d.f1()

In one of my projects, I also needed to do one particular thing, that is that even the underlying object should actually execute the method that was reimplemented in the decorator. It is actually quite easy to do if you know where to target it.

The use case is:

• I have an object X with methods A and B.
• I create a decorator class Y that overrides A.
• If I instantiate Y(X) and call A, it will use the decorated A as expected.
• If B calls A, then if I instantiate Y(X) and call B on the decorator, the call from within B then goes to the old A on the original object which was undesirable. I want the old B to call the new A as well.

It is possible to reach this behaviour like this:

import inspect
import six      # for handling 2-3 compatibility

class MyBaseDecorator(object):
    def __init__(self, decorated):
        self.decorated = decorated

    def __getattr__(self, attr):
       value = getattr(self.decorated, attr)
       if inspect.ismethod(value):
           function = six.get_method_function(value)
           value = function.__get__(self, type(self))
       return value

class SomeObject(object):
    def a(self):
        pass

    def b(self):
        pass

class MyDecorator(MyBaseDecorator):
    def a(self):
        pass

decorated = MyDecorator(SomeObject())

This may not work out of the box as I typed everything else apart from the getattr method from top of my head.

The code looks up the requested attribute in the decorated object, and if it is a method (doesn’t work for properties now, but the change to support them should not be too difficult), the code then pulls the actual function out of the method and using the descriptor interface invocation it “rebinds” the function as a method, but on the decorator. Then it is returned and most likely executed.

The effect of this is that if b ever calls a on the original object, then when you have the object decorated and there is any method call coming from the decorator, the decorator makes sure that all methods accessed are bound to the decorator instead, therefore looking up things using the decorator and not the original object, therefore the methods specified in the decorator taking precedence.

P.S.: Yes I know it looks pretty much like inheritance, but this done in the sense of composition of multiple objects.

In Python 3, Philipp’s accepted answer raised RuntimeError: maximum recursion depth exceeded.

The way that worked for me:

class Foo(object):
    def f1(self):
        print("original f1")

    def f2(self):
        print("original f2")

class FooDecorator(object):
    def __init__(self, decoratee):
        self._decoratee = decoratee

    def f1(self):
        print("decorated f1")
        return self._decoratee.f1()

    def __getattr__(self, name):
        if name in ['f1', '_decoratee']:
            raise AttributeError()
        return getattr(self._decoratee, name)

f = FooDecorator(Foo())
f.f1()
# decorated f1
# original f1
f.f2()
# original f2

The workaround is inspired by Ned Batchelder’s blog