¿Cómo puedo limpiar correctamente un objeto de Python?

Question

class Package: 
    def __init__(self): 
     self.files = [] 

    # ... 

    def __del__(self): 
     for file in self.files: 
      os.unlink(file) 

__del__(self) anterior falla con una excepción AttributeError. Entiendo Python doesn't guarantee la existencia de "variables globales" (datos de miembros en este contexto?) Cuando se invoca __del__(). Si ese es el caso y esta es la razón de la excepción, ¿cómo me aseguro de que el objeto se destruya correctamente?

Answer 1

Recomendaría usar la declaración with de Python para administrar los recursos que deben limpiarse. El problema con el uso de una declaración explícita de close() es que tiene que preocuparse de que las personas se olviden de llamarlo o se olviden de colocarlo en un bloque finally para evitar una pérdida de recursos cuando se produce una excepción.

utilizar la instrucción with, crear una clase con los siguientes métodos:

def __enter__(self) 
    def __exit__(self, exc_type, exc_value, traceback) 

En el ejemplo anterior, tendrá que utilizar

class Package: 
    def __init__(self): 
     self.files = [] 

    def __enter__(self): 
     return self 

    # ... 

    def __exit__(self, exc_type, exc_value, traceback): 
     for file in self.files: 
      os.unlink(file) 

Entonces, cuando alguien quería utilizar su clase , que harían lo siguiente:

with Package() as package_obj: 
    # use package_obj 

el package_obj variable será una instancia del tipo Paquete (es el valor devuelto por el método __enter__). Se llamará automáticamente a su método __exit__, independientemente de si se produce una excepción o no.

Incluso podría llevar este enfoque un paso más allá. En el ejemplo anterior, alguien aún podría instanciar el paquete usando su constructor sin usar la cláusula with. No quieres que eso suceda. Puede solucionarlo creando una clase PackageResource que defina los métodos __enter__ y __exit__. Entonces, la clase del paquete se definiría estrictamente dentro del método __enter__ y se devolvería.De esta manera, la persona que llama nunca podría crear una instancia de la clase del paquete sin necesidad de utilizar una declaración with:

class PackageResource: 
    def __enter__(self): 
     class Package: 
      ... 
     self.package_obj = Package() 
     return self.package_obj 

    def __exit__(self, exc_type, exc_value, traceback): 
     self.package_obj.cleanup() 

que tendría que utilizar esto como sigue:

with PackageResource() as package_obj: 
    # use package_obj 

Answer 2

Simplemente envuelva su destructor con una instrucción try/except y no arrojará una excepción si sus globales ya están eliminados.

Editar

Prueba esto:

from weakref import proxy 

class MyList(list): pass 

class Package: 
    def __init__(self): 
     self.__del__.im_func.files = MyList([1,2,3,4]) 
     self.files = proxy(self.__del__.im_func.files) 

    def __del__(self): 
     print self.__del__.im_func.files 

Será rellenar la lista de archivos en el del función que está garantizado para existir en el momento de la llamada. El proxy weakref es para evitar que Python, o usted mismo elimine la variable self.files de alguna manera (si se elimina, entonces no afectará la lista de archivos original). Si no es el caso de que esto se elimine aunque haya más referencias a la variable, entonces puede eliminar la encapsulación del proxy.

Answer 3

Parece que la forma idiomática de hacer esto es proporcionar un método close() (o similar) y llamarlo explícitamente.

Answer 4

No creo que es posible que los miembros de instancia para eliminarse antes de llamar al __del__. Supongo que la razón de su AttributeError particular está en otra parte (tal vez erróneamente elimine self.file en otro lugar).

Sin embargo, como los otros señalaron, debe evitar el uso de __del__. La razón principal de esto es que las instancias con __del__ no se recolectarán como basura (solo se liberarán cuando su recuento llegue a 0). Por lo tanto, si sus instancias están involucradas en referencias circulares, vivirán en la memoria mientras se ejecute la aplicación. (Sin embargo, puedo estar equivocado acerca de todo esto, tendría que volver a leer los documentos de gc, pero estoy bastante seguro de que funciona así).

Answer 5

Creo que el problema podría estar en __init__ si hay más código que el que se muestra?

__del__ se llamará incluso cuando __init__ no se ha ejecutado correctamente o inició una excepción.

Source

Answer 6

Como un apéndice a Clint's answer, puede simplificar PackageResource usando contextlib.contextmanager:

@contextlib.contextmanager 
def packageResource(): 
    class Package: 
     ... 
    package = Package() 
    yield package 
    package.cleanup() 

Como alternativa, aunque probablemente no tan Pythonic, puede anular Package.__new__:

class Package(object): 
    def __new__(cls, *args, **kwargs): 
     @contextlib.contextmanager 
     def packageResource(): 
      # adapt arguments if superclass takes some! 
      package = super(Package, cls).__new__(cls) 
      package.__init__(*args, **kwargs) 
      yield package 
      package.cleanup() 

    def __init__(self, *args, **kwargs): 
     ... 

y simplemente use with Package(...) as package.

para hacer las cosas más corto, el nombre de su función de limpieza close y utilizar contextlib.closing, en cuyo caso se puede utilizar la clase sin modificar Package través with contextlib.closing(Package(...)) o anular su __new__ a la más simple

class Package(object): 
    def __new__(cls, *args, **kwargs): 
     package = super(Package, cls).__new__(cls) 
     package.__init__(*args, **kwargs) 
     return contextlib.closing(package) 

Y este constructor se hereda , por lo que simplemente puede heredar, por ejemplo

class SubPackage(Package): 
    def close(self): 
     pass 

Answer 7

La forma habitual es utilizar atexit.register:

# package.py 
import atexit 
import os 

class Package: 
    def __init__(self): 
     self.files = [] 
     atexit.register(self.cleanup) 

    def cleanup(self): 
     print("Running cleanup...") 
     for file in self.files: 
      print("Unlinking file: {}".format(file)) 
      # os.unlink(file) 

Pero se debe tener en cuenta que este persistirá todas las instancias creadas de Package hasta que se termina Python.

demo usando el código anterior guardado como package.py:

$ python 
>>> from package import * 
>>> p = Package() 
>>> q = Package() 
>>> q.files = ['a', 'b', 'c'] 
>>> quit() 
Running cleanup... 
Unlinking file: a 
Unlinking file: b 
Unlinking file: c 
Running cleanup... 

Answer 8

Una mejor alternativa es utilizar weakref.finalize. Vea los ejemplos en Finalizer Objects y Comparing finalizers with __del__() methods.