¿Cómo limpio correctamente un objeto Python?

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

    # ...

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

__del__(self)arriba falla con una excepción AttributeError. Entiendo que Python no garantiza la existencia de "variables globales" (¿datos de miembros en este contexto?) Cuando __del__()se invoca. 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?

Recomiendo usar la withdeclaración de Python para administrar los recursos que necesitan ser limpiados. El problema con el uso de una close()declaración explícita es que debe preocuparse de que las personas se olviden de llamarlo o se olviden de colocarlo en un finallybloque para evitar una pérdida de recursos cuando se produce una excepción.

Para usar la withinstrucción, cree una clase con los siguientes métodos:

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

En su ejemplo anterior, usaría

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)

Luego, cuando alguien quisiera usar tu clase, haría lo siguiente:

with Package() as package_obj:
    # use package_obj

La variable package_obj será una instancia de tipo Package (es el valor devuelto por el __enter__método). Se __exit__llamará automáticamente a su método, independientemente de si se produce o no una excepción.

Incluso podría llevar este enfoque un paso más allá. En el ejemplo anterior, alguien aún podría crear una instancia de Package usando su constructor sin usar la withcláusula. No quieres que eso suceda. Puede solucionar esto creando una clase PackageResource que defina los métodos __enter__y __exit__. Luego, la clase Package se definiría estrictamente dentro del __enter__método y se devolvería. De esa manera, la persona que llama nunca podría crear una instancia de la clase Package sin usar una withdeclaración:

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()

Usarías esto de la siguiente manera:

with PackageResource() as package_obj:
    # use package_obj

La forma estándar es usar 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 debe tener en cuenta que esto persistirá en todas las instancias creadas Packagehasta que Python finalice.

Demostración utilizando 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...

Como apéndice a la respuesta de Clint , puede simplificar el PackageResourceuso de contextlib.contextmanager:

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

Alternativamente, aunque probablemente no sea 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 usar with Package(...) as package.

Para acortar las cosas, asigne un nombre a su función de limpieza closey úsela contextlib.closing, en cuyo caso puede usar la Packageclase no modificada with contextlib.closing(Package(...))o anularla __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

No creo que sea posible eliminar miembros antes de que __del__se llame. Supongo que la razón de su AttributeError particular está en otro lugar (tal vez elimine por error el archivo self en otro lugar).

Sin embargo, como señalaron los demás, debe evitar su uso __del__. La razón principal de esto es que las instancias con __del__no se recolectarán 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 leer los documentos de gc nuevamente, pero estoy bastante seguro de que funciona así).

Una mejor alternativa es usar weakref.finalize . Vea los ejemplos en Objetos finalizadores y Comparación de finalizadores con los métodos __del __ () .

Creo que el problema podría estar __init__si hay más código del que se muestra.

__del__se llamará incluso cuando __init__no se haya ejecutado correctamente o haya lanzado una excepción.

Fuente

Aquí hay un esqueleto de trabajo mínimo:

class SkeletonFixture:

    def __init__(self):
        pass

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

    def method(self):
        pass


with SkeletonFixture() as fixture:
    fixture.method()

Importante: volver a sí mismo

Si eres como yo y pasas por alto la return selfparte (de la respuesta correcta de Clint Miller ), estarás mirando estas tonterías:

Traceback (most recent call last):
  File "tests/simplestpossible.py", line 17, in <module>                                                                                                                                                          
    fixture.method()                                                                                                                                                                                              
AttributeError: 'NoneType' object has no attribute 'method'

Espero que ayude a la próxima persona.

Simplemente envuelva su destructor con una declaración try / except y no arrojará una excepción si sus globals 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

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

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