Decorators versus inheritance

Decorators...:

  • ...should be used if what you are trying to do is "wrapping". Wrapping consists of taking something, modifying (or registering it with something), and/or returning a proxy object that behaves "almost exactly" like the original.
  • ...are okay for applying mixin-like behavior, as long as you aren't creating a large stack of proxy objects.
  • ...have an implied "stack" abstraction:

e.g.

@decoA
@decoB
@decoC
def myFunc(...): ...
    ...

Is equivalent to:

def myFunc(...): ...
    ...
myFunc = decoA(decoB(decoC(myFunc)))  #note the *ordering*

Multiple inheritance...:

  • ... is best for adding methods to classes; you cannot use it to decorate functions easily. In this context, it can be used to achieve mixin-like behavior if all you need is a set of "duck-typing style" extra methods.
  • ... may be a bit unwieldy if your problem is not a good match for it, with issues with superclass constructors, etc. For example, the subclasses __init__ method will not be called unless it is called explicitly (via the method-resolution-order protocol)!

To sum up, I would use decorators for mixin-like behavior if they didn't return proxy objects. Some examples would include any decorator which returns the original function, slightly modified (or after registering it somewhere or adding it to some collection).

Things you will often find decorators for (like memoization) are also good candidates, but should be used in moderation if they return proxy objects; the order they are applied matter. And too many decorators on top of one another is using them in a way they aren't intended to be used.

I would consider using inheritance if it was a "classic inheritance problem", or if all I needed for the mixin behavior were methods. A classic inheritance problem is one where you can use the child wherever you could use the parent.

In general, I try to write code where it is not necessary to enhance arbitrary things.


The problem you reference is not deciding between decorators and classes. It is using decorators, but you have the option of using either:

  • a decorator, which returns a class
  • a decorator, which returns a function

A decorator is just a fancy name for the "wrapper" pattern, i.e. replacing something with something else. The implementation is up to you (class or function).

When deciding between them, it's completely a matter of personal preference. You can do everything you can do in one with the other.

  • if decorating a function, you may prefer decorators which return proxy functions
  • if decorating a class, you may prefer decorators which return proxy classes

(Why is it a good idea? There may be assumptions that a decorated function is still a function, and a decorated class is still a class.)

Even better in both cases would be to use a decorator which just returns the original, modified somehow.

edit: After better understanding your question, I have posted another solution at Python functools.wraps equivalent for classes

Tags:

Python

Inheritance

Decorator

Mixins

Recent Posts