Summer SALE

Composite を Python で

Composite 構造に関するデザインパターンの一つで オブジェクトを木のような構造に構成し あたかも単一のオブジェクトであるかのように扱えるようにします

Composite は ツリー構造の構築を必要とする問題の大部分の解決策として かなりの人気を得るようになりました Composite の大きな特徴は ツリー構造全体でメソッドを再帰的に実行し 結果をまとめあげることです



使用例 Composite パターンは Python コードではよく見かけます ユーザー・インターフェースのコンポーネントの階層構造の表現や グラフに対して動作するコードで多く使われます

見つけ方 オブジェクト・ツリーがあって ツリーのそれぞれのオブジェクトが同じクラス階層の部分であれば 十中八九 コンポジットです もしこれらのクラス中のメソッドが ツリーの子オブジェクトに仕事を委任し それを階層の基底クラスやインターフェースを介して行うなら これは間違いなくコンポジットです


この例は Composite デザインパターンの構造を説明するためのものです 以下の質問に答えることを目的としています

  • どういうクラスからできているか
  • それぞれのクラスの役割は
  • パターンの要素同士はどう関係しているのか 概念的な例

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.

    def parent(self) -> Component:
        return self._parent

    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:

    def remove(self, component: Component) -> None:

    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

    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


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 "Leaf"

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:
        component.parent = self

    def remove(self, component: Component) -> None:
        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:
        return f"Branch({'+'.join(results)})"

def client_code(component: Component) -> None:
    The client code works with all of the components via the base interface.

    print(f"RESULT: {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():

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

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

    # well as the complex composites.
    tree = Composite()

    branch1 = Composite()

    branch2 = Composite()


    print("Client: Now I've got a composite tree:")

    print("Client: I don't need to check the components classes even when managing the tree:")
    client_code2(tree, simple)

Output.txt: 実行結果

Client: I've got a simple component:

Client: Now I've got a composite tree:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf))

Client: I don't need to check the components classes even when managing the tree:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf)+Leaf)

他言語での Composite

Composite を C# で Composite を C++ で Composite を Go で Composite を Java で Composite を PHP で Composite を Ruby で Composite を Rust で Composite を Swift で Composite を TypeScript で