Spring SALE

Python 装饰模式讲解和代码示例

装饰是一种结构设计模式 允许你通过将对象放入特殊封装对象中来为原对象增加新的行为

由于目标对象和装饰器遵循同一接口 因此你可用装饰来对对象进行无限次的封装 结果对象将获得所有封装器叠加而来的行为



使用示例 装饰在 Python 代码中可谓是标准配置 尤其是在与流式加载相关的代码中

识别方法 装饰可通过以当前类或对象为参数的创建方法或构造函数来识别



  • 它由哪些类组成
  • 这些类扮演了哪些角色
  • 模式中的各个元素会以何种方式相互关联

main.py: 概念示例

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) -> Component:
        The Decorator delegates all work to the wrapped component.

        return self._component

    def operation(self) -> str:
        return self._component.operation()

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

    # ...

    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: 执行结果

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

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


C# 装饰模式讲解和代码示例 C++ 装饰模式讲解和代码示例 Go 装饰模式讲解和代码示例 Java 装饰模式讲解和代码示例 PHP 装饰模式讲解和代码示例 Ruby 装饰模式讲解和代码示例 Rust 装饰模式讲解和代码示例 Swift 装饰模式讲解和代码示例 TypeScript 装饰模式讲解和代码示例