Comment nettoyer correctement un objet Python ?

Question

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 Python ne garantit pas l'existence de "variables globales" (données membres dans ce contexte ?) lorsque __del__() est invoquée. Si c'est le cas et que c'est la raison de l'exception, comment puis-je m'assurer que l'objet se détruit correctement ?

Answer 1

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

Pour utiliser le with 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, quand quelqu'un veut utiliser votre classe, il fait ce qui suit :

with Package() as package_obj:
    # use package_obj

La variable package_obj sera une instance de type Package (c'est la valeur renvoyée par la fonction __enter__ méthode). Son site __exit__ sera automatiquement appelée, qu'une exception se produise ou non.

Vous pouvez même pousser cette approche un peu plus loin. Dans l'exemple ci-dessus, quelqu'un pourrait toujours instancier Package à l'aide de son constructeur sans utiliser l'attribut with clause. Vous ne voulez pas que cela se produise. Vous pouvez remédier à ce problème en créant une classe PackageResource qui définit l'attribut __enter__ y __exit__ méthodes. Ensuite, la classe Package serait définie strictement à l'intérieur de la classe __enter__ et retourné. De cette façon, l'appelant ne pourra jamais instancier la classe Package sans utiliser une méthode de type with déclaration :

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 l'utiliserez comme suit :

with PackageResource() as package_obj:
    # use package_obj

Answer 2

Je ne pense pas qu'il soit possible que les membres de l'instance soient retirés avant que __del__ est appelé. Je pense que la raison de votre AttributeError particulière se trouve ailleurs (vous avez peut-être supprimé par erreur self.file ailleurs).

Cependant, comme les autres l'ont souligné, vous devez éviter d'utiliser __del__ . La raison principale en est que les instances avec __del__ ne seront pas collectés (ils ne seront libérés 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 fonctionnera. (Je peux me tromper sur tout ceci, il faudrait que je relise la documentation gc, mais je suis plutôt sûr que ça fonctionne comme ça).

Answer 3

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

__del__ sera appelé même si __init__ n'a pas été exécuté correctement ou a déclenché une exception.

Source :

Answer 4

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

Editar

Essayez ç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 le fichier del dont l'existence est garantie au moment de l'appel. Le proxy weakref est destiné à 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 originale). Si ce n'est pas le cas, même s'il existe d'autres références à la variable, vous pouvez supprimer l'encapsulation du proxy.

Answer 5

Il semble que la manière idiomatique de le faire soit de fournir un fichier close() (ou une méthode similaire), et l'appeler de manière explicite.