复合模式逆序函数调用

Question

我有这样的复合 class。我想反向调用组件函数 order.I 意思是先调用最深的子函数，然后再调用一层，依此类推。

在下面的示例中，我根据复合对象的重量计算复合对象的重量 children.Thus 首先计算子项重量，然后根据子项重量计算父项重量。

我该怎么做？我应该使用哪种模式或算法？

class Component(object): 
    def __init__(self,desc,weight, *args, **kw):
        self.parent = None
        self.desc = desc
        self.weight_user_defined = weight
    def component_function(self):
        pass
    def setParent(self,parent):
        self.parent=parent

class Leaf(Component):
    def __init__(self,desc,weight,*args, **kw):
        Component.__init__(self,desc,weight, *args, **kw)

    def component_function(self):
        print (self.desc,self.weight_user_defined)

class Composite(Component):
    def __init__(self,desc,weight, *args, **kw):
        Component.__init__(self,desc,weight,*args, **kw)
        self.children = []
        self.weight_calculated = 0.0

    def append_child(self, child):
        self.children.append(child)
        child.setParent(self)

    def remove_child(self, child):
        self.children.remove(child)

    def component_function(self):      
        print (self.desc,self.weight_user_defined)
        for foo in self.children:
            foo.component_function()

举个例子：

ROOT (X kg)
    GLOCARY (Y kg)
        Apple  2.1 kg
        Banana 3.2 kg
    MISC (Z kg)  
        Stuff1 3.3 kg
        Stuff2 0.7 kg

于是为了求出X，首先计算Y和Z。（或者可能是树叶。例如数量*商品价格）

Answer 1

注意： 我不确定你所说的 "reverse order function call" 是什么意思，但这是你根据 [=35] 计算复合材料重量的方式=]仁.

没有children的Composite总是有weight=0。我认为 Composite 没有 children 时有 weight!=0 是没有意义的。

添加 child 时，将 child 的权重添加到 Composite 的权重。删除一个child时，减去它的权重。

class Component(object): 
    def __init__(self,desc,weight=0,*args,**kw):
        self.parent = None
        self.desc = desc
        self.weight = weight

    def setParent(self,parent):
        self.parent=parent

    def getWeight(self):
        raise NotImplementedError("Must instantiate subclass")

class Leaf(Component):
    def getWeight(self):
        return self.weight

class Composite(Component):
    def __init__(self,desc, *args, **kw):
        super(Composite,self).__init__(desc,*args, **kw)
        self.children = []

    def append_child(self, child):
        self.children.append(child)
        child.setParent(self)
        self.weight += child.getWeight()

    def remove_child(self, child):
        self.children.remove(child)
        self.weight -= child.getWeight()

    def getWeight(self):
        return self.weight

这里我通过添加Leafs和Composites作为另一个Composite的children来演示。

c1 = Composite("Composite 1")
c2 = Composite("Composite 2")

c1.append_child(Leaf("A leaf",5))
c1.append_child(Leaf("A leaf",5))
c1.append_child(Leaf("A leaf",5))

c2.append_child(Leaf("A leaf",1))
c2.append_child(Leaf("A leaf",1))
c2.append_child(Leaf("A leaf",1))

c1.append_child(c2)

输出

In [2]: print(c1.getWeight())
18

In [3]: c1.remove_child(c2)
   ...: print(c1.getWeight())
   ...: 
15

复合模式逆序函数调用

Composite Pattern reverse order function call

python

inheritance

composite

输出