¿Es seguro reemplazar un objeto propio por otro objeto del mismo tipo en un método?

Question

quisiera sustituir una instancia de objeto por otra instancia dentro de un método como este:

class A: 
    def method1(self): 
     self = func(self) 

El objeto se recupera de una base de datos.

Answer 1

Es poco probable que la sustitución de la variable 'yo' va a lograr lo que' Estoy tratando de hacer, eso no se puede lograr almacenando el resultado de func (self) en una variable diferente. 'self' es efectivamente una variable local solo definida por la duración de la llamada al método, utilizada para pasar en la instancia de la clase sobre la que se está operando. Reemplazar a uno mismo no reemplazará las referencias a la instancia original de la clase en poder de otros objetos, ni creará una referencia duradera a la nueva instancia que se le asignó.

Answer 2

Sí, todo lo que sucederá es que no podrá hacer referencia a la instancia actual de su clase A (a menos que establezca otra variable en self antes de cambiarla). No lo recomendaría sin embargo, hace que el código sea menos legible

Tenga en cuenta que solo está cambiando una variable, como cualquier otra. Hacer self = 123 es lo mismo que hacer abc = 123. self es solo una referencia a la instancia actual dentro del método. No puede cambiar su instancia configurando self.

Lo func(self) debe hacer es cambiar las variables de la instancia:

def func(obj): 
    obj.var_a = 123 
    obj.var_b = 'abc' 

luego hacer esto:

class A: 
    def method1(self): 
     func(self) # No need to assign self here 

Answer 3

No es una respuesta directa a la pregunta, pero en los puestos de abajo hay una solución para lo que Amirouche tratado de hacer:

• Python object conversion
• Can I dynamically convert an instance of one class to another?

y aquí está el código de trabajo muestra (Python 3.2.5).

class Men: 
    def __init__(self, name): 
     self.name = name 

    def who_are_you(self): 
     print("I'm a men! My name is " + self.name) 

    def cast_to(self, sex, name): 
     self.__class__ = sex 
     self.name = name 

    def method_unique_to_men(self): 
     print('I made The Matrix') 


class Women: 
    def __init__(self, name): 
     self.name = name 

    def who_are_you(self): 
     print("I'm a women! My name is " + self.name) 

    def method_unique_to_women(self): 
     print('I made Cloud Atlas') 


men = Men('Larry') 
men.who_are_you() 
#>>> I'm a men! My name is Larry 
men.method_unique_to_men() 
#>>> I made The Matrix 


men.cast_to(Women, 'Lana') 
men.who_are_you() 
#>>> I'm a women! My name is Lana 
men.method_unique_to_women() 
#>>> I made Cloud Atlas 

Nota del self.__class__ y no self.__class__.__name__. Es decir. esta técnica no solo reemplaza el nombre de clase, sino que convierte una instancia de una clase (al menos ambos tienen el mismo id()). Además, 1) No sé si es "seguro reemplazar un objeto propio por otro objeto del mismo tipo en el método [de un objeto]"; 2) trabaja con diferentes tipos de objetos, no solo con los que son del mismo tipo; 3) no funciona exactamente como quería amirouche: no puedes iniciar la clase como Class(args), solo Class() (no soy profesional y no puedo responder por qué es así).

Answer 4

Se puede usar la autoasignación en un método para cambiar la clase de instancia a una clase derivada.

Por supuesto, se podría asignar a un nuevo objeto, pero luego el uso del nuevo objeto ondula a través del resto del código en el método. Al reasignarlo a uno mismo, deja el resto del método intacto.

class aclass: 

    def methodA(self): 
     ... 
     if condition: 
      self = replace_by_derived(self) 
      # self is now referencing to an instance of a derived class 
      # with probably the same values for its data attributes 

     # all code here remains untouched 
     ... 
     self.methodB() # calls the methodB of derivedclass is condition is True 
     ... 

    def methodB(self): 
     # methodB of class aclass 
     ... 

class derivedclass(aclass): 
    def methodB(self): 
     #methodB of class derivedclass 
     ... 

Pero aparte de un caso de uso tan especial, no veo ninguna ventaja para reemplazar a uno mismo.

Answer 5

Por lo que entiendo, si está tratando de reemplazar el objeto actual con otro objeto del mismo tipo (suponiendo que func no cambiará el tipo de objeto) desde una función miembro. Creo que esto logrará que

class A: 
def method1(self): 
    newObj = func(self) 
    self.__dict__.update(newObj.__dict__) 

Answer 6

Sí, no hay nada de malo en esto. Personas con odio van a odiar. (Mirando a Pycharm con su in most cases imaginable, there's no point in such reassignment and it indicates an error).

Una situación en la que usted puede hacer esto es:

some_method(self, ...): 

    ... 

    if(some_condition): 
     self = self.some_other_method() 

    ... 

    return ... 

Claro, usted podría comenzar el cuerpo del método reasignando self a alguna otra variable, pero si no lo haría normalmente que con otros parámetros, por qué hacerlo con self?