Sostituzione del metodo in fase di runtime non aggiornando Attributi privati ​​

Question

Ho capito come sostituire i metodi in fase di esecuzione in Python passando attraverso questi collegamenti. [Link1, Link2, & Link3].

Quando ho sostituito un metodo "update_private_variable" di classe A, è stato sostituito ma non ha aggiornato la variabile privata.

import types 

class A: 
    def __init__(self): 
     self.__private_variable = None 
     self.public_variable = None 

    def update_private_variable(self): 
     self.__private_variable = "Updated in A" 

    def update_public_variable(self): 
     self.public_variable = "Updated in A" 

    def get_private_variable(self): 
     return self.__private_variable 

class B: 
    def __init__(self): 
     self.__private_variable = None 
     self.public_variable = None 

    def update_private_variable(self): 
     self.__private_variable = "Updated in B" 

    def update_public_variable(self): 
     self.public_variable = "Updated in B" 

Quando si chiama il metodo senza sostituzione:

a_instance = A() 
a_instance.update_private_variable() 
print(a_instance.get_private_variable()) 
#prints "Updated in A" 

Quando si chiama il metodo dopo la sostituzione:

a_instance = A() 
a_instance.update_private_variable = types.MethodType(B.update_private_variable, a_instance) 
a_instance.update_private_variable() 
print(a_instance.get_private_variable()) 
#prints None 

Mentre la sostituzione e chiamando un metodo che aggiorna variabile pubblica, funziona bene

a_instance = A() 
a_instance.update_public_variable = types.MethodType(B.update_public_variable, a_instance) 
a_instance.update_public_variable() 
print(a_instance.public_variable) 
#prints 'Updated in B' 

Esiste un altro modo per sostituire il metodo di un'istanza in fase di esecuzione, in modo che gli attributi privati ​​vengano aggiornati richiamando il metodo sostituito?

Answer 1

L'idea alla base del nome manomissione consiste nel proteggere le variabili di classe base dall'essere incasinato dalle sottoclassi; in altre parole, non dovresti usarlo se pensi che le sottoclassi avranno una buona ragione per modificare quelle stesse variabili.

Detto questo, se si è già bene su questa strada e sono in grado (o non vogliono) per farla cambiare ora, è ancora possibile ottenere da, ma sarà brutto e fragili:

class B: 

    def update_private_variable(self): 
     self._A__private_variable = "Updated in B" 

Come si può vedere, si ha come prefisso la variabile nome-storpiato con una _ e il nome della classe della variabile è storpiato in alcune delle conseguenze:.

• se si cambia il nome della classe, è necessario cambia il nome in tutti i riferimenti ad esso
• non è possibile utilizzare facilmente lo stesso metodo update_private_variable (poiché è necessario indicare in qualche modo la classe di destinazione ... suppongo che si possa passare alla classe target al metodo, ma questo è solo più la bruttezza)