如何将此装饰器更改为Python？

Question

I have gotten a copy of the book "Head First Design Patterns", and started to codify some of their examples in Python. I have came to the example about the Decorator pattern, which I know it should use composition, but the author puts a sort of "inheritance". The excuse was that the decorator was made to "achieve the type matching, but not to used it to inherit behaviour". I have a question here, I know that Python is not a typed language so when I the example from the book (which is in Java), I got this:

from abc import ABCMeta, abstractmethod

class Beverage:
    __metaClass__=ABCMeta

    def __init__(self):
        self.Description="Beverage desconocida"

    def getDescription(self):
        return self.Description

    @abstractmethod
    def calc(self):
        pass


class CondimentDecorator(Beverage):
    __metaClass__=ABCMeta

    @abstractmethod
    def getDescription(self):
        pass

class Espresso(Beverage):
    def __init__(self):
        self.Description="Espresso"

    def calc(self):
        return 2.5

class Pasado(Beverage):
    def __init__(self):
        self.Description="Roasted coffee"

    def calc(self):
        return 1.5

class Mocha(CondimentDecorator):
    def __init__(self,Beverage):
        self.Beverage=Beverage

    def getDescription(self):
        return self.Beverage.getDescription()+" Mocha "

    def calc(self):
        return 0.5+self.Beverage.calc()

def main():
    Beverage=Espresso()
    print Beverage.getDescription()," cost: ",Beverage.calc()
    Beverage2=Pasado()
    Beverage2=Mocha(Beverage2)
    print Beverage2.getDescription()," cost: ",Beverage2.calc()
    Beverage3=Espresso()
    Beverage3=Mocha(Mocha(Beverage3))
    print Beverage3.getDescription()," cost: ",Beverage3.calc()

I wonder if the class:

CondimentDecorator(Beverage)

is well done, because as long as Python has no types, I would not need to inherit from Beverage; am I right?

If I change it like:

CondimentDecorator(), my code works still, but in that case I wonder if its necessary to have it, because it has only one abstract method and that's it.

Do I need to change my code to be more consistent with the Python OOP Programming?

Thanks

Answer 1

Python has no strict typing and often there is no need in inheritance or abstract classes. A Decorator-Class is needed for the decorator pattern, because it should define every method of the decorated class to call the method of the embedded instance. If you overwrite all methods, you strictly don't need this decorator class. Here is a version without inheritance:

class Espresso(object):
    description="Espresso"

    def calc(self):
        return 2.5

class Pasado(object):
    description="Roasted coffee"

    def calc(self):
        return 1.5

class Mocha(object):
    def __init__(self, beverage):
        self.beverage = beverage

    @property
    def description(self):
        return self.beverage.description+" Mocha"

    def calc(self):
        return 0.5+self.beverage.calc()

def main():
    beverage = Espresso()
    print beverage.description, " cost: ", beverage.calc()
    beverage2 = Pasado()
    beverage2 = Mocha(beverage2)
    print beverage2.description, " cost: ", beverage2.calc()
    beverage3 = Espresso()
    beverage3 = Mocha(Mocha(beverage3))
    print beverage3.description, " cost: ", beverage3.calc()

if __name__ == '__main__':
    main()

On the other side, Python is a dynamic language, and you could write an dynamic decorator

class GenericDecorator(object): def init (self, obj): self.obj = obj

    def __getattr__(self, name):
        return getattr(self.obj, name)

class Flavored(GenericDecorator):
    """Flavor is for free"""
    def __init__(self, beverage, flavor):
        GenericDecorator.__init__(self, beverage)
        self.flavor = flavor

    @property
    def description(self):
        return self.flavor + '-' + self.obj.description

def main():
    beverage = Espresso()
    beverage = Flavored(beverage, 'Vanilla')
    print beverage.description, " cost: ", beverage.calc()

if __name__ == '__main__':
    main()