Wie bereinige ich ein Python-Objekt richtig?

Question

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

    # ...

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

__del__(self) schlägt mit einer AttributeError-Ausnahme fehl. Ich verstehe Python garantiert nicht das Vorhandensein von "globalen Variablen" (Mitgliedsdaten in diesem Zusammenhang?), wenn __del__() aufgerufen wird. Wenn das der Fall ist und dies der Grund für die Ausnahme ist, wie kann ich sicherstellen, dass das Objekt ordnungsgemäß zerstört wird?

Answer 1

Ich empfehle die Verwendung von Pythons with Anweisung zur Verwaltung von Ressourcen, die bereinigt werden müssen. Das Problem bei der Verwendung einer expliziten close() Anweisung ist, dass man sich Sorgen machen muss, dass die Leute vergessen, sie überhaupt aufzurufen, oder dass sie vergessen, sie in eine finally Block, um ein Ressourcenleck zu verhindern, wenn eine Ausnahme auftritt.

Zur Verwendung des with Anweisung erstellen Sie eine Klasse mit den folgenden Methoden:

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

In Ihrem obigen Beispiel würden Sie Folgendes 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, musste er Folgendes tun:

with Package() as package_obj:
    # use package_obj

Die Variable package_obj ist eine Instanz des Typs Package (es ist der Wert, der von der Methode __enter__ Methode). Seine __exit__ Methode wird automatisch aufgerufen, unabhängig davon, ob eine Ausnahme auftritt oder nicht.

Sie könnten sogar noch einen Schritt weiter gehen. Im obigen Beispiel könnte jemand ein Paket mit seinem Konstruktor instanziieren, ohne die with Klausel. Sie wollen nicht, dass das passiert. Sie können dies beheben, indem Sie eine PackageResource-Klasse erstellen, die die __enter__ y __exit__ Methoden. Dann würde die Paketklasse streng innerhalb der __enter__ Methode und zurückgegeben. Auf diese Weise konnte der Aufrufer die Paketklasse nie instanziieren, ohne eine with Erklärung:

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

Answer 2

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

Sie sollten jedoch bedenken, dass dadurch alle erstellten Instanzen von Package bis Python beendet wird.

Demo unter Verwendung des obigen Codes gespeichert als paket.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 3

Eine bessere Alternative ist die Verwendung von weakref.finalisieren . Siehe die Beispiele unter Finalizer-Objekte y Vergleich von Finalizern mit __del__()-Methoden .

Answer 4

Als Anhang zu Clint's Antwort können Sie vereinfachen PackageResource mit contextlib.contextmanager :

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

Alternativ, wenn auch wahrscheinlich nicht als Pythonic, können Sie ü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 verwenden Sie einfach with Package(...) as package .

Um die Sache kürzer zu machen, benennen Sie Ihre Aufräumfunktion close und verwenden contextlib.closing in diesem Fall können Sie entweder die unveränderte Package Klasse über with contextlib.closing(Package(...)) oder überschreiben Sie seine __new__ zum einfacheren

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 vererbt, Sie können also einfach erben, z. B.

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

Answer 5

Hier ist ein minimales Arbeitsgerüst:

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

Das ist wichtig: Selbst zurückgeben

---

Wenn Sie wie ich sind und die return self Teil (von Die richtige Antwort von Clint Miller ), 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'

Ich hoffe, es hilft der nächsten Person.