Wie bereinige ich ein Python-Objekt korrekt?

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

    # ...

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

__del__(self)oben schlägt mit einer AttributeError-Ausnahme fehl. Ich verstehe, dass Python beim Aufrufen nicht die Existenz von "globalen Variablen" (Mitgliedsdaten in diesem Kontext?) Garantiert__del__() . Wenn dies der Fall ist und dies der Grund für die Ausnahme ist, wie stelle ich sicher, dass das Objekt ordnungsgemäß zerstört wird?

Ich würde empfehlen, die Python- withAnweisung zum Verwalten von Ressourcen zu verwenden, die bereinigt werden müssen. Das Problem bei der Verwendung einer expliziten close()Anweisung besteht darin, dass Sie sich Sorgen machen müssen, dass Personen vergessen, sie überhaupt aufzurufen oder sie in einem finallyBlock zu platzieren, um ein Ressourcenleck zu verhindern, wenn eine Ausnahme auftritt.

withErstellen Sie eine Klasse mit den folgenden Methoden, um die Anweisung zu verwenden:

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

In Ihrem obigen Beispiel würden Sie verwenden

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)

Wenn dann jemand Ihre Klasse benutzen wollte, würde er Folgendes tun:

with Package() as package_obj:
    # use package_obj

Die Variable package_obj ist eine Instanz vom Typ Package (dies ist der von der __enter__Methode zurückgegebene Wert ). Die __exit__Methode wird automatisch aufgerufen, unabhängig davon, ob eine Ausnahme auftritt oder nicht.

Sie könnten diesen Ansatz sogar noch einen Schritt weiter gehen. Im obigen Beispiel könnte jemand Package weiterhin mit seinem Konstruktor instanziieren, ohne die withKlausel zu verwenden. Du willst nicht, dass das passiert. Sie können dies beheben, indem Sie eine PackageResource-Klasse erstellen, die die Methoden __enter__und definiert __exit__. Dann würde die Package-Klasse streng innerhalb der __enter__Methode definiert und zurückgegeben. Auf diese Weise konnte der Aufrufer die Package-Klasse niemals instanziieren, ohne eine withAnweisung zu verwenden:

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

Sie würden dies wie folgt verwenden:

with PackageResource() as package_obj:
    # use package_obj

Die Standardmethode ist 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)

Beachten Sie jedoch, dass alle erstellten Instanzen so lange bestehen bleiben, Packagebis Python beendet wird.

Demo mit dem oben als package.py gespeicherten Code :

$ 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...

Als Anhang zu Clint Antwort , können Sie vereinfachen PackageResourcemit contextlib.contextmanager:

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

Alternativ, obwohl wahrscheinlich nicht als Pythonic, können Sie Folgendes überschreiben 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):
        ...

und einfach benutzen with Package(...) as package.

Um die Dinge kürzer zu machen, benennen Sie Ihre Bereinigungsfunktion closeund verwenden Sie sie contextlib.closing. In diesem Fall können Sie entweder die unveränderte PackageKlasse über verwenden with contextlib.closing(Package(...))oder __new__die einfachere überschreiben

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

Und dieser Konstruktor wird geerbt, so dass Sie einfach erben können, z

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

Ich denke nicht, dass es möglich ist, dass beispielsweise Mitglieder entfernt werden, bevor sie __del__aufgerufen werden. Ich vermute, dass der Grund für Ihren speziellen AttributeError woanders liegt (vielleicht entfernen Sie self.file fälschlicherweise woanders).

Wie die anderen betonten, sollten Sie jedoch die Verwendung vermeiden __del__. Der Hauptgrund dafür ist, dass Instanzen mit __del__nicht mit Müll gesammelt werden (sie werden erst freigegeben, wenn ihr Refcount 0 erreicht). Wenn Ihre Instanzen an Zirkelverweisen beteiligt sind, bleiben sie daher so lange im Speicher, wie die Anwendung ausgeführt wird. (Ich kann mich bei all dem irren, ich müsste die gc-Dokumente noch einmal lesen, aber ich bin mir ziemlich sicher, dass es so funktioniert).

Eine bessere Alternative ist die Verwendung von schwachref.finalize . Siehe die Beispiele unter Finalizer-Objekte und Vergleichen von Finalisierern mit __del __ () -Methoden .

Ich denke, das Problem könnte darin liegen, __init__dass mehr Code als gezeigt vorhanden ist.

__del__wird auch dann aufgerufen, wenn __init__es nicht richtig ausgeführt wurde oder eine Ausnahme ausgelöst hat.

Quelle

Hier ist ein minimales Arbeitsskelett:

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

Wichtig: kehre selbst zurück

Wenn Sie wie ich sind und den return selfTeil (von Clint Millers korrekter Antwort ) übersehen , werden Sie auf diesen Unsinn starren:

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

Hoffe es hilft der nächsten Person.

Schließen Sie Ihren Destruktor einfach mit einer try / exception-Anweisung ein, und es wird keine Ausnahme ausgelöst, wenn Ihre Globals bereits entsorgt sind.

Bearbeiten

Versuche dies:

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

Die Dateiliste wird in die del- Funktion eingefügt, die zum Zeitpunkt des Aufrufs garantiert vorhanden ist. Der schwache Ref-Proxy soll verhindern, dass Python oder Sie selbst die Variable self.files irgendwie löschen (wenn sie gelöscht wird, hat dies keine Auswirkungen auf die ursprüngliche Dateiliste). Wenn dies nicht der Fall ist, wird dies gelöscht, obwohl mehr Verweise auf die Variable vorhanden sind, können Sie die Proxy-Kapselung entfernen.

Es scheint, dass der idiomatische Weg, dies zu tun, darin besteht, eine close()Methode (oder eine ähnliche) bereitzustellen und sie explizit aufzurufen.