Python, wie verschiedene Instanzen derselben Klasse in eine Iteration

Question

Mein Problem erstellen ist:

Ich mag eine Composite-Klasse Objekte Blatt zur Laufzeit innerhalb eine Composite-Routine wie folgt erstellt hinzuzufügen:

def update(self, tp, msg, stt): 
    """It updates composite objects 
    """ 
    d = Leaf() 
    d.setDict(tp, msg, stt) 
    self.append_child(d) 

    return self.status() 

Innenhaupt:

import lib.composite 
c = Composite() 
for i in range(0,10): 
    c.update(str(i), msg, stt) 

und der Verbund:

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

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

    def update(self, tp, msg, stt): 
     d = Leaf() 
     d.setDict(tp, msg, stt) 
     self.append_child(d) 
     return self.status() 

    def status(self): 
     for child in self.children: 
      ret = child.status() 
      if type(child) == Leaf: 
       p_out("Leaf: %s has value %s" % (child, ret)) 

class Component(object): 
    def __init__(self, *args, **kw): 
     if type(self) == Component: 
      raise NotImplementedError("Component couldn't be " 
             "instantiated directly") 

    def status(self, *args, **kw): 
     raise NotImplementedError("Status method " 
            "must be implemented") 

class Leaf(Component): 

    def __init__(self): 
     super(Leaf, self).__init__() 
     self._dict = {} 

    def setDict(self, type, key, value) 
     self._dict = { type : { key : value } } 

    def status(self): 
     return self._dict 

Aber auf diese Weise fand ich immer, dass mein Composite nur ein Blatt ("d") hinzugefügt hat, selbst wenn Update mehrmals aufgerufen wurde.

Wie kann ich eine solche Routine so programmieren, dass Composite zur Laufzeit gefüllt werden kann?

Answer 1

Was macht das append_child? Ich denke, es sollte die Blätter in einer Liste speichern. Macht es?

Update: Sie sollten nicht selbst als erstes Argument in der Hauptfunktion übergeben. Ich denke, dass es eine Ausnahme aufwirft.

Siehe Code unten das scheint

 
class Component(object): 
    def __init__(self, *args, **kw): 
     pass 

    def setDict(self, *args, **kw): 
     pass 

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

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

    def update(self, tp, msg, stt): 
     """It updates composite objects 
     """ 
     d = Leaf() 
     d.setDict(tp, msg, stt) 
     self.append_child(d) 

     return 0 

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

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

c =Composite() 
for i in range(0,10): 
    c.update(str(i), "", 0) 
print len(c.children) 

Answer 2

ok zu arbeiten „Aber auf diese Weise fand ich immer, dass mein Verbund hat nur ein Blatt (“ d „) hinzugefügt, auch wenn Update oft genannt wurde.“

Nein, dieser Code macht Composite mit zehn Kindern.

>>> c.children 
[<__main__.Leaf object at 0xb7da77ec>, <__main__.Leaf object at 0xb7da780c>, 
<__main__.Leaf object at 0xb7da788c>, <__main__.Leaf object at 0xb7da78ac>, 
<__main__.Leaf object at 0xb7da78cc>, <__main__.Leaf object at 0xb7da792c>, 
<__main__.Leaf object at 0xb7da794c>, <__main__.Leaf object at 0xb7da798c>, 
<__main__.Leaf object at 0xb7da79ac>, <__main__.Leaf object at 0xb7da79cc>] 

Also warum Sie denken, es hat nur eine ist seltsam.