tiefer verschachteltes objekt hinzufügen

[ts7343]

Hallo,

ich hab leider einen Knoten im Gehirn, kann mal jemand auf den Code schauen

in der Instance von PartAll wurden zwei Part objekte erzeugt,
nun soll ein nset in ein nsetAll gepackt werden und dieses zu part 1 hinzugefügt werden,

wie komme ich da hin?

Code: Alles auswählen

class Model:
   def __init__(self): 
      self.partAll      = PartAll()

class PartAll:
   def __init__(self): 
      self.partDict = {}
   def add_part_to_dict(self, part, part_id):
      self.partDict[part_id] = part
   def get_debug_output(self):
      print self.partDict.keys()

class Part:
   def __init__(self):
      self.nsetAll      = NsetAll()

class NsetAll:
   def __init__(self): self.nsetDict = {}
   def add_nset_to_nset_all(self, nset, id):
      self.nsetDict[id] = nset
   def get_debug_output(self):
      print self.nsetDict

class Nset:
   def __init__(self, value, id):
      self.value = value
      self.id = id
      
mod = Model()
part = Part()
mod.partAll.add_part_to_dict(part, 1)
mod.partAll.add_part_to_dict(part, 2)
mod.partAll.get_debug_output()
nset = Nset(1,1)
# add nset object to nset all and put nset all into part 1

[snafu]

in der Instance von PartAll wurden zwei Part objekte erzeugt,

Das zeigt dein Quelltext so aber nicht. Da wird nämlich nur ein Part-Objekt erzeugt und dieses eine Objekt wird mehrfach (d.h. unter zwei verschiedenen IDs) dem PartAll-Objekt hinzugefügt.

nun soll ein nset in ein nsetAll gepackt werden und dieses zu part 1 hinzugefügt werden,

Na, du nutzt die entsprechende add...()-Methode des nsetAll-Objekts, ganz ähnlich wie beim PartAll-Objekt.

Um dies dann einem Part-Objekt anzuhängen, müsstest du tricksen, weil es von der API in der gezeigten Form nicht direkt angeboten wird. Daher dann notdürftig:

Code: Alles auswählen

part = Part()
part.nsetAll = NsetAll()
part.nsetAll.add_nset_to_nset_all(...)

Vermutlich liegt dir aber in Wirklichkeit ganz anderer Code vor, den du selbst umformuliert hast, um es besser erklären zu können. Ich kann dir aus Erfahrung hierzu nur sagen: Lass solche Dinge sein. Versuche besser, die tatsächlichen Aufrufe möglichst als lauffähiges Minimalbeispiel darzustellen. Sonst musst du deinen Pseudocode, für den man es hier ja nur erklären kann, nochmals übersetzen in deinen echten Code. Und das kann äußerst fehleranfällig sein...

[ts7343]

Hallo snafu,

danke, dass du dir das anschaust,
und du hast recht, es ist recht schwer es nachzubilden,

dieses update erklaert es nun besser:
- im vorfeld werden zwei part instanzen erzeugt die zu partAll addiert werden,
- beide part instanzen besitzen eine Instanz von nsetAll, welches aber spaeter gefuellt wird
- nun erzeuge ich zu einem spaeteren Zeitpunkt nsets, die zu einem part gehoeren
mein Problem:
- fuege die nset in ein nsetAll, aber genau in das zugehörige, welches schon im jeweiligen part initialisiert wurde,

Code: Alles auswählen

class Model:
   def __init__(self): 
      self.partAll      = PartAll()

class PartAll:
   def __init__(self): 
      self.partDict = {}
   def add_part_to_dict(self, part, part_id):
      self.partDict[part_id] = part
   def get_part_ids(self):
      return self.partDict.keys()
   def get_part_obj_by_id(self, id):
      return self.partDict[id]
   def get_debug_output(self):
      print self.partDict.keys()

class Part:
   def __init__(self, id):
      self.part_id = id
      self.nsetAll = NsetAll()
   def get_debug_output(self):
      return self.part_id, "len of nsetAll: " + str(self.nsetAll.get_length())

class NsetAll:
   def __init__(self): 
      self.nsetDict = {}
   def add_nset_to_nset_all(self, nset, id):
      self.nsetDict[id] = nset
   def get_length(self):
      return len(self.nsetDict.keys())
   def get_debug_output(self):
      print self.nsetDict

class Nset:
   def __init__(self, value, id):
      self.value = value
      self.id = id
      
      
mod = Model()
# creating parts
for id in range(2):
   part = Part(id)
   mod.partAll.add_part_to_dict(part, id)
mod.partAll.get_debug_output()
# creating nsets for each part
for part_id in mod.partAll.get_part_ids():
   nset_id = part_id + 10
   nset = Nset(part_id + 10, nset_id)
   # add now nset instance to nsetAll, that was initialized before in part instance

[snafu]

mein Problem:
- fuege die nset in ein nsetAll, aber genau in das zugehörige, welches schon im jeweiligen part initialisiert wurde,

Dann solltest du beim Erzeugen das zugehörige nsetAll dir irgendwo merken. Entweder durch eine Referenz direkt auf's Objekt oder über die ID. In letzterem Fall kannst du das Objekt dann mittels ID zurückholen.

Um was geht es denn? Arbeitest du mit einer Datenbank? Hast du volle Kontrolle über die Daten oder werden die dir aus einer anderen Quelle geliefert? Nicht dass du in Wirklichkeit mit SQLAlchemy arbeitest und hierfür die ganze Zeit mit umständlichen Umschreibungen kommst...

[ts7343]

naja, das ganze soll ein Translator werden, und so soll erst mal das Memory Model aufgebaut werden um später die Daten von dort zu ziehen.

wäre diese Art von Code ok, um das nset-objekt zu addieren, oder gibt es da noch elegantere Methoden ?

Code: Alles auswählen

part = mod.partAll.get_part_obj_by_id(part_id)
# add now nset instance to nsetAll, that was initialized before in part instance
part.nsetAll.add_nset_to_nset_all(nset, nset_id)

[snafu]

Deine Methodennamen sind ziemlich lang. nsetAll würde ich einfach nsets nennen und diesem eine Methode mit dem schlichten Namen add() verpassen. Dann könnte es noch eine delegierende Methode auf einem Part-Objekt geben:

Code: Alles auswählen

def add_nset(self, nset, id):
    self.nsets.add(nset, id)

So würde ich das zumindest machen. Aber jeder hat ja einen anderen Stil.

EDIT:
Und anstatt die IDs vom Aufrufer übergeben zu lassen, könnte man das vielleicht auch intern regeln:

Code: Alles auswählen

class Part(self):
    def __init__(self):
        self.nsets = NSets()
        self._next_id = 0

    def add_nset(self, nset):
        nset_id = self._next_id
        self.nsets.add(nset, nset_id)
        self._next_id += 1
        return nset_id