¿Cómo recargar el código de un método de objeto de clase en Python?

He encontrado una forma de volver a cargar el método de un objeto de clase en tiempo de ejecución, aquí está el ejemplo: Primero definí una clase A que se encuentra en el archivo test.py.

class A: def __init_(self): pass def Message(self): print "1" 

Luego inicio el shell de Python en Linux y ejecuto el siguiente código:

 >>> from test import A >>> a = A() >>> a.Message() 1 

Ahora veo el test.py en la marcha, y cambio el método “Mensaje”:

 class A: def __init_(self): pass def Message(self): print "2" 

pero cuando ejecuto a.Message () en el shell de Python, el resultado es siempre el “1” y no el “2”

Cómo escribo el código para hacer que el objeto ‘a.Message’ ejecute el código actualizado.

    ¡Muchas gracias!

    chu

    Para reorientar su módulo en el intérprete interactivo, puede usar

     import test reload(test) from test import A 

    Pero esto no afectará a la instancia de A que ya existe; seguirán siendo del tipo antiguo A , por lo tanto, tendrán el método antiguo. Creo que no es posible cambiar las instancias existentes, ni creo que sea una buena idea.

    Por cierto, recomendaría usar IPython para probar el código. Facilita la recarga recursiva utilizando el %reload magic, y (aún más útil) el %run magic para probar los módulos.

    Acabo de pasar un tiempo tratando de resolver este problema por mi cuenta y terminé con una solución ligeramente diferente a las otras que se sugieren aquí. Lo he puesto en una lista con muchos comentarios, pero como es la forma en la que voy a dar una breve explicación aquí:

    En lugar de modificar instancias individuales de una versión antigua de una clase, o copiarlas en nuevas instancias de la nueva clase, la idea es establecer los métodos de la clase antigua (es decir, los atributos de la clase en sí no las instancias de la clase) Ser los métodos actualizados de la nueva clase. También se encarga de volver a encadenar varias versiones de la clase.

    Debe volver a cargar su módulo desde el código nuevo, obtener la clase y asignarlo de nuevo a la instancia:

     import sys def update_class(instance): cls=instance.__class__ modname=cls.__module__ del sys.modules[modname] module=__import__(modname) instance.__class__=getattr(module,cls.__name__) 

    Mientras desarrolla y actualiza el código, puede usar el mismo truco para definir instancias que recarguen su clase en cualquier momento que se usen.

     import sys class ObjDebug(object): def __getattribute__(self,k): ga=object.__getattribute__ sa=object.__setattr__ cls=ga(self,'__class__') modname=cls.__module__ mod=__import__(modname) del sys.modules[modname] reload(mod) sa(self,'__class__',getattr(mod,cls.__name__)) return ga(self,k) class A(ObjDebug): pass a=A() 

    Si edita el código de A para agregar un método, entonces puede usarlo sin crear una instancia de nuevo a.

    En realidad, del sys.modules[modname] parece crear errores desagradables para los cuales algunos símbolos se convierten en objetos Ninguno de una línea a otra. (no entendido por qué)