Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
indem du die settattr Methoden überschreibst und dir solche Hooks einbaust.
€dit sagt, da gibts nen Modul für, aber im Prinzip ist da ne Speziallösung vermutlich besser.
Wenn du die Dinge tatsächlich als "3*foo" eingeben willst, muss eben "x*foo" nen Proxy erstellen.
allerdings bin ich noch nicht so lange dabei als das dich das genau verstehe. Das ganze klingt ziemlich kompliziert..... Was muss ich den jetzt mit der von dir geposteten Lösung tun?
Ich bin gerade am grübeln ob das sich das nicht auch einfacher verwalten lässt, d.h ob ich eine andere Datenstruktur verwenden könnte....
Wo genau im Code hast du denn Probleme?
Probier einfach mal mit Teilstücken des Codes im Interpreter rum und schau in die Doku des operator und des functools Moduls. Sind alles keine schweren Dinge.
Die die object.__getattr__ Sache muss ich da machen, da ein self.foo schon wieder die eigene __getattr__ Methode aufruft und ich so eine Endlosschleife baue.
audax hat geschrieben:Aber na andere Datenstruktur wäre auch gut
Ok was ich machen möchte ist ein Interface für ein Programm schreiben, das dem Code Variablen übergibt. Die Variablen sichere ich in dictionaries, dabei ist der Variablenname der Schlüssel und der Wert der Variable der Wert. Was mich da schon stört, ist dass ich dictionaries nicht anordnen kann, außerdem würde ich gerne eine Erklärung noch irgendwie für jede Variable mitspeichern. Der User soll alle Variablen ändern können. Manche Variablen hängen von anderen Variablen ab - daher der Kunstgriff... Am Ende wird der Inhalt aller dictionaries in ein File geschrieben, dass dann die Schnittstelle darstellt.
Wie könnte denn die Datenstruktur sonst aussehen? Eventuell könnte man das über geschachtelte Listen realisieren?
Hmm, ich muss dann aber für jede neue Variable eine neue Instanz der Klasse erzeugen. Jetzt brauche ich Methoden, um zu prüfen, ob eine Varible definiert ist und ggf. den Wert zu ändern. Deshalb bin ich ja auf dictionaries gekommen - die bringen diese Methoden von Haus aus mit.
jens hat geschrieben:Bau einfach eine Klasse dafür. So in der Art:
Naja, du hast dann eben Funktionen statt direkter Werte, die du erst aufrufen musst. Also musst du, wenn du einen Wert abrufst, entweder ausserhalb explizit überprüfen ob du ein Funktionsobjekt zurückbekommst oder einen Wert, oder du definierst einen Boolean Status, der dir anzeigt, ob das jetzt ein "statischer" oder ein dynamischer Wert ist. Zum Beispiel könnte jeder Wert des Dict ein Tupel sein, dessen erstes Argument wie gehabt der jeweilige Wert ist und als zweiten Wert True oder False. Dokumentieren tust du das dann als "is_dynamic" oder sowas. Dann reicht ein
Der Initialzustand ist so stimmig. Allerdings wird die Variable "tmp" nach einer Änderung von "wert1" natürlich nicht dynamisch aktualisiert - gibt es dafür Möglichkeiten?
Dann müsste man allerdings die Funktionen, die man braucht, gesondert abspeichern und sich eine Datenstruktur ausdenken, die alle Statischen Namen, von denen der neue Wert abhängt, in einer One to Many Relation abbilden, etwa einem Neuen dict mit <neuer_wert> => <tupel von alten werten>>. Das müsste dann in einer bestimmten Reihenfolge als Parameter an die Funktionen gegeben werden. Zumindest, wenn man das ganze generisch implementieren will. Schließlich soll das ja ein Dictionary sein, und nicht eine DoWhatEverIWantionary. Erledingt man das gleiche gleich mit lambda zuweisungen, braucht man nur sich das jeweils aktuelle Dict generieren lassen, indem man die Funktionen auswertet, die auf das Dict selbst mittels Closure Zugriff haben.