Comment nettoyer correctement un objet Python?

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

    # ...

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

__del__(self)ci-dessus échoue avec une exception AttributeError. Je comprends que Python ne garantit pas l'existence de "variables globales" (données de membre dans ce contexte?) Lorsqu'il __del__()est invoqué. Si tel est le cas et que c'est la raison de l'exception, comment puis-je m'assurer que l'objet se détruit correctement?

Je recommande d'utiliser la withdéclaration de Python pour gérer les ressources qui doivent être nettoyées. Le problème avec l'utilisation d'une close()déclaration explicite est que vous devez vous inquiéter du fait que les gens oublient de l'appeler ou oublient de le placer dans un finallybloc pour éviter une fuite de ressources lorsqu'une exception se produit.

Pour utiliser l' withinstruction, créez une classe avec les méthodes suivantes:

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

Dans votre exemple ci-dessus, vous utiliseriez

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)

Ensuite, lorsque quelqu'un voulait utiliser votre classe, il procédait comme suit:

with Package() as package_obj:
    # use package_obj

La variable package_obj sera une instance de type Package (c'est la valeur retournée par la __enter__méthode). Sa __exit__méthode sera automatiquement appelée, qu'une exception se produise ou non.

Vous pourriez même aller plus loin dans cette approche. Dans l'exemple ci-dessus, quelqu'un pourrait toujours instancier Package en utilisant son constructeur sans utiliser la withclause. Vous ne voulez pas que cela se produise. Vous pouvez résoudre ce problème en créant une classe PackageResource qui définit les méthodes __enter__et __exit__. Ensuite, la classe Package serait définie strictement à l'intérieur de la __enter__méthode et renvoyée. De cette façon, l'appelant n'a jamais pu instancier la classe Package sans utiliser une withinstruction:

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

Vous utiliseriez ceci comme suit:

with PackageResource() as package_obj:
    # use package_obj

La méthode standard consiste à utiliser 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)

Mais vous devez garder à l'esprit que toutes les instances créées persisteront Packagejusqu'à ce que Python soit terminé.

Démo utilisant le code ci-dessus enregistré sous 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...

En annexe à la réponse de Clint , vous pouvez simplifier en PackageResourceutilisant contextlib.contextmanager:

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

Alternativement, mais probablement pas en Pythonic, vous pouvez remplacer 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):
        ...

et utilisez simplement with Package(...) as package.

Pour raccourcir les choses, nommez closeet utilisez votre fonction de nettoyage contextlib.closing, auquel cas vous pouvez soit utiliser la Packageclasse non modifiée via, with contextlib.closing(Package(...))soit la remplacer __new__par la plus simple.

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

Et ce constructeur est hérité, vous pouvez donc simplement hériter, par exemple

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

Je ne pense pas qu'il soit possible par exemple de supprimer des membres avant d' __del__appeler. Je suppose que la raison de votre AttributeError particulière est ailleurs (peut-être que vous supprimez par erreur self.file ailleurs).

Cependant, comme les autres l'ont souligné, vous devez éviter de l'utiliser __del__. La raison principale en est que les instances avec __del__ne seront pas récupérées (elles ne seront libérées que lorsque leur refcount atteindra 0). Par conséquent, si vos instances sont impliquées dans des références circulaires, elles resteront en mémoire aussi longtemps que l'application s'exécutera. (Je me trompe peut-être cependant, je devrais relire les documents gc, mais je suis plutôt sûr que cela fonctionne comme ça).

Une meilleure alternative consiste à utiliser le fichier lowref.finalize . Voir les exemples dans Finalizer Objects et Comparaison des finaliseurs avec les méthodes __del __ () .

Je pense que le problème pourrait être __init__s'il y a plus de code que celui indiqué?

__del__sera appelé même s'il __init__n'a pas été exécuté correctement ou a levé une exception.

La source

Voici un squelette de travail minimal:

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

Important: retournez-vous

Si vous êtes comme moi et que vous négligez la return selfpartie (de la bonne réponse de Clint Miller ), vous regarderez ce non-sens:

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

J'espère que cela aide la prochaine personne.

Enveloppez simplement votre destructeur avec une instruction try / except et il ne lèvera pas d'exception si vos globaux sont déjà éliminés.

Éditer

Essaye ça:

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

Il remplira la liste des fichiers dans la fonction del qui est garantie d'exister au moment de l'appel. Le proxy de faiblesse est d'empêcher Python ou vous-même de supprimer la variable self.files d'une manière ou d'une autre (si elle est supprimée, cela n'affectera pas la liste de fichiers d'origine). Si ce n'est pas le cas que cela est supprimé même s'il y a plus de références à la variable, vous pouvez supprimer l'encapsulation du proxy.

Il semble que la façon idiomatique de le faire est de fournir une close()méthode (ou similaire), et de l'appeler explicitement.