Jak poprawnie wyczyścić obiekt Python?

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

    # ...

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

__del__(self)powyżej kończy się niepowodzeniem z wyjątkiem wyjątku AttributeError. Rozumiem, że Python nie gwarantuje istnienia „zmiennych globalnych” (danych członka w tym kontekście?), Gdy __del__()zostanie wywołany. Jeśli tak jest i to jest powód wyjątku, w jaki sposób mogę upewnić się, że obiekt zniszczy się prawidłowo?

Polecam użycie withinstrukcji Pythona do zarządzania zasobami, które wymagają oczyszczenia. Problem z używaniem wyraźnego close()stwierdzenia polega na tym, że musisz się martwić, że ludzie w ogóle zapomną go nazwać lub zapomną umieścić go wfinally bloku, aby zapobiec wyciekom zasobów w przypadku wystąpienia wyjątku.

Aby użyć withinstrukcji, utwórz klasę przy użyciu następujących metod:

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

W powyższym przykładzie użyłbyś

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)

Następnie, gdy ktoś chciałby skorzystać z twojej klasy, zrobiłby to:

with Package() as package_obj:
    # use package_obj

Zmienna package_obj będzie instancją typu Package (jest to wartość zwracana przez __enter__metodę). Jego__exit__ metoda zostanie automatycznie wywołana, niezależnie od tego, czy wystąpi wyjątek.

Możesz nawet pójść o krok dalej. W powyższym przykładzie ktoś nadal może utworzyć instancję pakietu przy użyciu swojego konstruktora bez użycia withklauzuli. Nie chcesz, żeby tak się stało. Możesz to naprawić, tworząc klasę PackageResource, która definiuje metody __enter__i __exit__. Następnie klasa Package zostanie zdefiniowana ściśle wewnątrz __enter__metody i zwrócona. W ten sposób osoba dzwoniąca nigdy nie może utworzyć instancji klasy Package bez użycia withinstrukcji:

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

Użyłbyś tego w następujący sposób:

with PackageResource() as package_obj:
    # use package_obj

Standardowym sposobem jest użycie 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)

Należy jednak pamiętać, że spowoduje to zachowanie wszystkich utworzonych instancji do Packagemomentu zakończenia działania Pythona.

Demo przy użyciu powyższego kodu zapisanego jako 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...

Jako dodatek do odpowiedzi Clinta możesz uprościć, PackageResourceużywając contextlib.contextmanager:

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

Alternatywnie, choć prawdopodobnie nie jako Python, możesz zastąpić 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):
        ...

i po prostu użyj with Package(...) as package .

Aby wszystko było krótsze, nazwij swoją funkcję czyszczenia closei użyj contextlib.closing, w którym to przypadku możesz albo użyć niezmodyfikowanej Packageklasy, with contextlib.closing(Package(...))albo zastąpić ją __new__prostszą

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

I ten konstruktor jest dziedziczony, więc możesz po prostu odziedziczyć, np

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

Nie sądzę, że możliwe jest na przykład usunięcie członków przed __del__wywołaniem. Domyślam się, że przyczyną konkretnego błędu AttributeError jest gdzie indziej (być może błędnie usuwasz plik self.file w innym miejscu).

Jednak, jak zauważyli inni, należy unikać używania __del__. Głównym tego powodem jest to, że instancje z __del__nie będą zbierane śmieci (zostaną one uwolnione dopiero, gdy ich licznik osiągnie 0). Dlatego jeśli instancje są zaangażowane w odwołania cykliczne, będą one istnieć w pamięci tak długo, jak aplikacja będzie działać. (Mogę się jednak mylić co do tego, musiałbym ponownie przeczytać dokumentację gc, ale raczej jestem pewien, że tak to działa).

Lepszą alternatywą jest użycie słabyref.finalizuj . Zobacz przykłady w Finalizer Objects i Porównanie finalizatorów z metodami __del __ () .

Myślę, że problem może występować, __init__jeśli jest więcej kodów niż pokazano?

__del__zostanie wywołany, nawet jeśli __init__nie został poprawnie wykonany lub nie zgłosił wyjątku.

Źródło

Oto minimalny działający szkielet:

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

Ważne: zwróć siebie

Jeśli jesteś podobny do mnie i przeoczysz tę return selfczęść ( poprawnej odpowiedzi Clinta Millera ), będziesz patrzył na ten nonsens:

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

Mam nadzieję, że to pomoże następnej osobie.

Po prostu zawiń destruktor instrukcją try / wyjątek, a nie wyrzuci on wyjątku, jeśli twoje globały są już usunięte.

Edytować

Spróbuj tego:

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

Wypełni listę plików w funkcji del, która z pewnością istnieje w momencie wywołania. Słaby serwer proxy ma uniemożliwić Pythonowi lub tobie usunięcie zmiennej self.files w jakiś sposób (jeśli zostanie ona usunięta, nie wpłynie to na oryginalną listę plików). Jeśli nie jest tak, że jest on usuwany, mimo że istnieje więcej odwołań do zmiennej, możesz usunąć enkapsulację proxy.

Wydaje się, że idiomatycznym sposobem na to jest podanie close()metody (lub podobnej) i wyraźne jej wywołanie.