Bagaimana cara membersihkan objek Python dengan benar?

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

    # ...

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

__del__(self)di atas gagal dengan pengecualian AttributeError. Saya mengerti Python tidak menjamin keberadaan "variabel global" (data anggota dalam konteks ini?) Ketika __del__()dipanggil. Jika itu yang terjadi dan ini adalah alasan pengecualian, bagaimana cara memastikan objek rusak dengan benar?

Saya akan merekomendasikan menggunakan withpernyataan Python untuk mengelola sumber daya yang perlu dibersihkan. Masalah dengan menggunakan close()pernyataan eksplisit adalah Anda harus khawatir tentang orang yang lupa menyebutnya sama sekali atau lupa menempatkannya di finallyblok untuk mencegah kebocoran sumber daya ketika pengecualian terjadi.

Untuk menggunakan withpernyataan, buat kelas dengan metode berikut:

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

Dalam contoh Anda di atas, Anda akan menggunakan

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)

Kemudian, ketika seseorang ingin menggunakan kelas Anda, mereka akan melakukan hal berikut:

with Package() as package_obj:
    # use package_obj

Variabel package_obj akan menjadi turunan dari tipe Paket (ini adalah nilai yang dikembalikan oleh __enter__metode). Its __exit__metode secara otomatis akan dipanggil, terlepas dari apakah atau tidak pengecualian terjadi.

Anda bahkan bisa mengambil pendekatan ini selangkah lebih maju. Pada contoh di atas, seseorang masih dapat membuat Instantiate menggunakan konstruktornya tanpa menggunakan withklausa. Anda tidak ingin itu terjadi. Anda bisa memperbaikinya dengan membuat kelas PackageResource yang mendefinisikan __enter__dan __exit__metode. Kemudian, kelas Paket akan didefinisikan secara ketat di dalam __enter__metode dan dikembalikan. Dengan begitu, penelepon tidak pernah dapat membuat instance kelas Paket tanpa menggunakan withpernyataan:

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

Anda akan menggunakan ini sebagai berikut:

with PackageResource() as package_obj:
    # use package_obj

Cara standar adalah dengan menggunakan 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)

Tetapi Anda harus ingat bahwa ini akan bertahan semua contoh yang dibuat Packagesampai Python dihentikan.

Demo menggunakan kode di atas disimpan sebagai 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...

Sebagai lampiran dari jawaban Clint , Anda dapat menyederhanakan PackageResourcemenggunakan contextlib.contextmanager:

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

Atau, meskipun mungkin bukan sebagai Pythonic, Anda dapat mengesampingkan 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):
        ...

dan cukup gunakan with Package(...) as package.

Untuk mendapatkan yang lebih singkat, beri nama fungsi pembersihan Anda closedan gunakan contextlib.closing, dalam hal ini Anda dapat menggunakan Packagekelas yang tidak dimodifikasi melalui with contextlib.closing(Package(...))atau menimpanya __new__ke yang lebih sederhana

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

Dan konstruktor ini diwarisi, jadi Anda bisa mewarisi, misalnya

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

Saya tidak berpikir bahwa mungkin anggota misalnya untuk dihapus sebelum __del__dipanggil. Dugaan saya adalah bahwa alasan untuk AttributeError khusus Anda adalah di tempat lain (mungkin Anda salah menghapus self.file di tempat lain).

Namun, seperti yang ditunjukkan orang lain, Anda harus menghindari penggunaan __del__. Alasan utama untuk ini adalah bahwa instance dengan __del__tidak akan menjadi sampah yang dikumpulkan (mereka hanya akan dibebaskan ketika refcount mereka mencapai 0). Oleh karena itu, jika instance Anda terlibat dalam referensi melingkar, mereka akan hidup dalam memori selama aplikasi berjalan. (Saya mungkin salah tentang semua ini, saya harus membaca gc docs lagi, tapi saya agak yakin ini berfungsi seperti ini).

Alternatif yang lebih baik adalah dengan menggunakan lemahref . Finalisasi . Lihat contoh di Finalizer Objects dan Membandingkan finalizer dengan metode __del __ () .

Saya pikir masalahnya bisa di __init__jika ada lebih banyak kode daripada yang ditunjukkan?

__del__akan dipanggil bahkan ketika __init__belum dieksekusi dengan benar atau melemparkan pengecualian.

Sumber

Berikut ini kerangka kerja 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()

Penting: kembalikan diri

Jika Anda seperti saya, dan mengabaikan return selfbagian (dari jawaban Clint Miller yang benar ), Anda akan menatap omong kosong ini:

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

Semoga ini bisa membantu orang selanjutnya.

Hanya bungkus destruktor Anda dengan pernyataan try / kecuali dan itu tidak akan membuang pengecualian jika global Anda sudah dibuang.

Edit

Coba ini:

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

Ini akan memasukkan daftar file dalam fungsi del yang dijamin ada pada saat panggilan. Proxy lemahref adalah untuk mencegah Python, atau Anda sendiri menghapus variabel self.files, entah bagaimana (jika dihapus, maka itu tidak akan memengaruhi daftar file asli). Jika bukan karena ini sedang dihapus meskipun ada lebih banyak referensi ke variabel, maka Anda dapat menghapus enkapsulasi proxy.

Tampaknya cara idiomatis untuk melakukan ini adalah dengan memberikan close()metode (atau yang serupa), dan menyebutnya dengan jelas.