🎉 Hooray! After 3 years of work, I've finally released the ebook on design patterns! Check it out »

Decorator in Python

Decorator is a Conceptual pattern that allows adding new behaviors to objects dynamically by placing them inside special wrapper objects.

Using decorators you can wrap objects countless number of times since both target objects and decorators follow the same interface. The resulting object will get a stacking behavior of all wrappers.

Learn more about Decorator

Usage of the pattern in Python



Usage examples: The Decorator is pretty standard in Python code, especially in code related to streams.

Identification: Decorator can be recognized by creational methods or constructor that accept objects of the same class or interface as a current class.

Conceptual Example

This example illustrates the structure of the Decorator design pattern. It focuses on answering these questions:

  • What classes does it consists of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

main.py: Conceptual Example

class Component():
    The base Component interface defines operations that can be altered by

    def operation(self) -> str:

class ConcreteComponent(Component):
    Concrete Components provide default implementations of the operations.
    There might be several variations of these classes.

    def operation(self) -> str:
        return "ConcreteComponent"

class Decorator(Component):
    The base Decorator class follows the same interface as the other
    components. The primary purpose of this class is to define the wrapping
    interface for all concrete decorators. The default implementation of the
    wrapping code might include a field for storing a wrapped component and
    the means to initialize it.

    _component: Component = None

    def __init__(self, component: Component) -> None:
        self._component = component

    def component(self) -> str:
        The Decorator delegates all work to the wrapped component.

        return self._component

    def operation(self) -> str:

class ConcreteDecoratorA(Decorator):
    Concrete Decorators call the wrapped object and alter its result in some

    def operation(self) -> str:
        Decorators may call parent implementation of the operation, instead
        of calling the wrapped object directly. This approach simplifies
        extension of decorator classes.
        return f"ConcreteDecoratorA({self.component.operation()})"

class ConcreteDecoratorB(Decorator):
    Decorators can execute their behavior either before or after the call to
    a wrapped object.

    def operation(self) -> str:
        return f"ConcreteDecoratorB({self.component.operation()})"

def client_code(component: Component) -> None:
    The client code works with all objects using the Component interface.
    This way it can stay independent of the concrete classes of components it
    works with.

    # ...

    print(f"RESULT: {component.operation()}", end="")

    # ...

if __name__ == "__main__":
    # This way the client code can support both simple components...
    simple = ConcreteComponent()
    print("Client: I've got a simple component:")

    # ...as well as decorated ones.
    # Note how decorators can wrap not only simple components but the other
    # decorators as well.
    decorator1 = ConcreteDecoratorA(simple)
    decorator2 = ConcreteDecoratorB(decorator1)
    print("Client: Now I've got a decorated component:")

Output.txt: Output

Client: I've got a simple component:
RESULT: ConcreteComponent

Client: Now I've got a decorated component:
RESULT: ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))

Decorator in Other Languages

Decorator in Java Decorator in C# Decorator in PHP Decorator in TypeScript