Python verwenden Lazy-Zuweisung beim Übergeben von Listen an Methoden

Question

Ich habe eine Python-Klasse A und seine Kind B. Ich mache ein Objekt der Klasse B übergeben einige Listen-Argumente, die in B angehängt sind und das Ergebnis in Klasse A. Ich würde gerne eines dieser Argumente ändern und sehen, dass sich die Änderung ohne weiteres widerspiegelt. Lassen Sie mich mit einem Beispiel erklären:

class A(): 
    def __init__(self,data): 
     self.a=data 

class B(A): 
    def __init__(self,x,y): 
     self.x=x 
     self.y=y 
     A.__init__(self,self.x+self.y) 

    def change_x(self,x): 
     self.x = x 

Jetzt, wen ich laufe

test = B([1, 2], [3,4]) 
print(test.a) 

ich offensichtlich [1,2,3,4]. Wenn ich Teil der Liste wie folgt ändern:

test.change_x([3,4]) 
print(test.a) 

Ich würde [3,4,3,4] bekommen, anstatt natürlich erhalte ich [1,2,3,4]. Natürlich wird test.a nur während der Instanziierung ausgewertet.

Ich verstehe, warum das nicht der Fall ist, und ich lese über Generatoren, aber es gelingt mir nicht herauszufinden, wie dies zu implementieren ist. Ich möchte nicht mit einem iterablen Ergebnis enden, das ich nur einmal durchlaufen kann.

Konnte mir jemand helfen? Ein sauberer Weg, um das zu lösen?

Answer 1

Gibt es einen Grund, die Klasse A überhaupt zu haben? Sie könnten eine Eigenschaft oder Methode a erstellen, die innerhalb der Klasse B den gewünschten Wert zurückgibt.

class B(): 
    def __init__(self, x, y): 
     self.x = x 
     self.y = y 

    def change_x(self, x): 
     self.x = x 

    @property 
    def a(self): 
     return self.x + self.y 


test = B([1, 2], [3, 4]) 
print(test.a) # [1, 2, 3, 4] 

test.change_x([3, 4]) 
print(test.a) # [3, 4, 3, 4] 

Kleine Anmerkung: Mit dieser Implementierung die change_x Methode nicht erforderlich sein sollte. Es ist im Allgemeinen mehr Pythonic, nur direkt auf Attribute zuzugreifen (z. B. test.x = x), als Getter und Setter zu verwenden.

Answer 2

Sie müssen es "manuell" implementieren. Zum Beispiel, wie so:

class B(A): 
    def __init__(self,x,y): 
     self.x=x 
     self.y=y 
     self.spread_changes() 

    def change_x(self,x): 
     self.x = x 
     self.spread_changes() 

    def spread_changes(self): 
     A.__init__(self,self.x+self.y) 

Answer 3

Ich endete damit, alle Teile von self.a (in A) direkt zu speichern, indem ich sie aus ihren Klassen erschneide. Ich fügte eine Methode "B.update_crc (self)" hinzu, wie sie von Israel Unterman vorgeschlagen wurde, um bestimmte Teile von self.a im Falle einer Modifikation neu zu bewerten.

Danke, mein erster Ansatz wan't genau das Richtige :)