Python: Composite Pattern

DuComposite.py

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

# 组合模式 Composite  Pattern from __future__ import annotations from abc import ABC, abstractmethod from typing import List     class Component(ABC):     """     The base Component class declares common operations for both simple and     complex objects of a composition.     """       @property     def parent(self) -> Component:         return self._parent       @parent.setter     def parent(self, parent: Component):         """         Optionally, the base Component can declare an interface for setting and         accessing a parent of the component in a tree structure. It can also         provide some default implementation for these methods.         """           self._parent = parent       """     In some cases, it would be beneficial to define the child-management     operations right in the base Component class. This way, you won't need to     expose any concrete component classes to the client code, even during the     object tree assembly. The downside is that these methods will be empty for     the leaf-level components.     """       def add(self, component: Component) -> None:         pass       def remove(self, component: Component) -> None:         pass       def is_composite(self) -> bool:         """         You can provide a method that lets the client code figure out whether a         component can bear children.         """           return False       @abstractmethod     def operation(self) -> str:         """         The base Component may implement some default behavior or leave it to         concrete classes (by declaring the method containing the behavior as         "abstract").         """           pass     class Leaf(Component):     """     The Leaf class represents the end objects of a composition. A leaf can't     have any children.       Usually, it's the Leaf objects that do the actual work, whereas Composite     objects only delegate to their sub-components.     """       def operation(self) -> str:         return "叶子"     class Composite(Component):     """     The Composite class represents the complex components that may have     children. Usually, the Composite objects delegate the actual work to their     children and then "sum-up" the result.     """       def __init__(self) -> None:         self._children: List[Component] = []       """     A composite object can add or remove other components (both simple or     complex) to or from its child list.     """       def add(self, component: Component) -> None:         self._children.append(component)         component.parent = self       def remove(self, component: Component) -> None:         self._children.remove(component)         component.parent = None       def is_composite(self) -> bool:         return True       def operation(self) -> str:         """         The Composite executes its primary logic in a particular way. It         traverses recursively through all its children, collecting and summing         their results. Since the composite's children pass these calls to their         children and so forth, the whole object tree is traversed as a result.         """           results = []         for child in self._children:             results.append(child.operation())         return f"分枝({'+'.join(results)})"     def client_code(component: Component) -> None:     """     The client code works with all of the components via the base interface.     """       print(f"结果: {component.operation()}", end="")     def client_code2(component1: Component, component2: Component) -> None:     """     Thanks to the fact that the child-management operations are declared in the     base Component class, the client code can work with any component, simple or     complex, without depending on their concrete classes.     """       if component1.is_composite():         component1.add(component2)       print(f"结果: {component1.operation()}", end="")

　　

main.py

调用：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# 组合模式 Composite  Pattern # This way the client code can support the simple leaf components... simple = DuComposite.Leaf() print("客户端: 我有一个简单的组件:") DuComposite.client_code(simple) print("\n")   # ...as well as the complex composites. tree = DuComposite.Composite()   branch1 = DuComposite.Composite() branch1.add(DuComposite.Leaf()) branch1.add(DuComposite.Leaf())   branch2 = DuComposite.Composite() branch2.add(DuComposite.Leaf())   tree.add(branch1) tree.add(branch2)   print("客户端: 现在我有了一个合成树:") DuComposite.client_code(tree) print("\n")   print("客户端: 我不需要检查组件类，即使在管理树:") DuComposite.client_code2(tree, simple)

　　

输出：

?

1 2 3 4 5 6 7 8

客户端: 我有一个简单的组件: 结果: 叶子   客户端: 现在我有了一个合成树: 结果: 分枝(分枝(叶子+叶子)+分枝(叶子))   客户端: 我不需要检查组件类，即使在管理树: 结果: 分枝(分枝(叶子+叶子)+分枝(叶子)+叶子)