ฉันจะล้างวัตถุ Python อย่างถูกต้องได้อย่างไร

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

    # ...

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

__del__(self)ด้านบนล้มเหลวด้วยข้อยกเว้นของ AttributeError ฉันเข้าใจว่าPython ไม่รับประกันการมีอยู่ของ "ตัวแปรทั่วโลก" (ข้อมูลสมาชิกในบริบทนี้?) เมื่อ__del__()มีการเรียกใช้ หากเป็นเช่นนั้นและนี่คือเหตุผลสำหรับข้อยกเว้นฉันจะแน่ใจได้อย่างไรว่าวัตถุถูกทำลายอย่างถูกต้อง

ฉันขอแนะนำให้ใช้withคำสั่งPython สำหรับการจัดการทรัพยากรที่จำเป็นต้องทำความสะอาด ปัญหาเกี่ยวกับการใช้close()คำสั่งที่ชัดเจนคือคุณต้องกังวลเกี่ยวกับคนที่ลืมโทรเลยหรือลืมวางไว้ในfinallyบล็อกเพื่อป้องกันการรั่วไหลของทรัพยากรเมื่อมีข้อยกเว้นเกิดขึ้น

ในการใช้withคำสั่งให้สร้างคลาสด้วยวิธีการต่อไปนี้:

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

ในตัวอย่างด้านบนคุณจะใช้

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)

จากนั้นเมื่อมีคนต้องการใช้คลาสของคุณพวกเขาจะทำสิ่งต่อไปนี้:

with Package() as package_obj:
    # use package_obj

ตัวแปร package_obj จะเป็นตัวอย่างของประเภทแพคเกจ (มันเป็นค่าที่ส่งกลับโดย__enter__วิธีการ) __exit__วิธีการของมันจะถูกเรียกโดยอัตโนมัติไม่ว่าจะมีข้อยกเว้นเกิดขึ้นหรือไม่

คุณสามารถใช้แนวทางนี้อีกก้าวหนึ่ง ในตัวอย่างข้างต้นบางคนอาจจะยังคง instantiate แพคเกจโดยใช้ตัวสร้างได้โดยไม่ต้องใช้withประโยค คุณไม่ต้องการที่จะเกิดขึ้น คุณสามารถแก้ไขได้โดยสร้างคลาส PackageResource ที่กำหนด__enter__และ__exit__วิธีการ จากนั้นคลาสแพ็กเกจจะถูกกำหนดอย่างเคร่งครัดภายใน__enter__เมธอดและส่งคืน ด้วยวิธีนี้ผู้เรียกจะไม่สามารถยกระดับคลาสแพ็คเกจได้โดยไม่ต้องใช้withคำสั่ง

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

คุณจะใช้สิ่งนี้ดังนี้:

with PackageResource() as package_obj:
    # use package_obj

วิธีมาตรฐานคือการใช้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)

แต่คุณควรจำไว้ว่าสิ่งนี้จะคงอยู่อินสแตนซ์ที่สร้างขึ้นทั้งหมดPackageจนกว่า Python จะถูกยกเลิก

สาธิตโดยใช้รหัสด้านบนบันทึกเป็น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...

ในฐานะที่เป็นภาคผนวกของคำตอบของ Clintคุณสามารถลดความซับซ้อนของการPackageResourceใช้contextlib.contextmanager:

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

อีกทางเลือกหนึ่งแม้ว่าอาจจะไม่ได้เป็น Pythonic คุณสามารถแทนที่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):
        ...

with Package(...) as packageและเพียงแค่ใช้

เพื่อให้สิ่งต่าง ๆ สั้นลงให้ตั้งชื่อฟังก์ชั่นการล้างข้อมูลcloseและการใช้งานของcontextlib.closingคุณซึ่งในกรณีนี้คุณสามารถใช้Packageคลาสที่ไม่มีการแก้ไขผ่านwith contextlib.closing(Package(...))หรือแทนที่มัน__new__เพื่อให้ง่ายขึ้น

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

และคอนสตรัคเตอร์นี้ได้รับการสืบทอดดังนั้นคุณสามารถสืบทอดเช่น

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

ฉันไม่คิดว่าเป็นไปได้ที่สมาชิกอินสแตนซ์ที่จะลบก่อนหน้า__del__นี้จะถูกเรียก ฉันเดาว่าเหตุผลสำหรับ AttributeError ของคุณนั้นอยู่ที่อื่น (บางทีคุณอาจลบไฟล์ self.file ที่อื่น)

อย่างไรก็ตามในขณะที่คนอื่น ๆ __del__ชี้ให้เห็นคุณควรหลีกเลี่ยงการใช้ เหตุผลหลักสำหรับกรณีนี้คืออินสแตนซ์ที่มี__del__จะไม่ถูกรวบรวมขยะ (พวกเขาจะได้รับอิสรภาพเมื่อ refcount ถึง 0) ดังนั้นหากอินสแตนซ์ของคุณเกี่ยวข้องกับการอ้างอิงแบบวงกลมพวกเขาจะอยู่ในหน่วยความจำตราบเท่าที่แอปพลิเคชันทำงาน (ฉันอาจจะเข้าใจผิดเกี่ยวกับสิ่งนี้แม้ว่าฉันจะต้องอ่านเอกสาร gc อีกครั้ง แต่ฉันค่อนข้างแน่ใจว่ามันทำงานเช่นนี้)

ทางเลือกที่ดีคือการใช้weakref.finalize ดูตัวอย่างที่Finalizer วัตถุและfinalizers เปรียบเทียบกับ __del __ () วิธี

ฉันคิดว่าปัญหาอาจเกิดขึ้นใน__init__กรณีที่มีรหัสมากกว่าที่แสดง?

__del__จะถูกเรียกแม้ว่า__init__จะไม่ได้ดำเนินการอย่างถูกต้องหรือมีข้อยกเว้น

แหล่ง

นี่คือโครงกระดูกการทำงานที่น้อยที่สุด:

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

สำคัญ: คืนตัวเอง

หากคุณชอบฉันและมองข้ามreturn selfส่วน (ของคำตอบที่ถูกต้องของClint Miller ) คุณจะจ้องมองเรื่องไร้สาระนี้:

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

หวังว่ามันจะช่วยให้คนต่อไป

เพียงแค่หุ้ม destructor ของคุณด้วยคำสั่งลอง / ยกเว้นและมันจะไม่ส่งข้อยกเว้นถ้าคุณกำจัดทิ้งไปแล้ว

แก้ไข

ลองสิ่งนี้:

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

มันจะบรรจุรายการไฟล์ในฟังก์ชั่นเดลที่รับประกันว่าจะมีอยู่ในเวลาที่โทร พร็อกซีที่อ่อนแอคือการป้องกัน Python หรือตัวคุณเองจากการลบตัวแปร self.files อย่างใด (ถ้ามันถูกลบไปแล้วมันจะไม่ส่งผลกระทบต่อรายชื่อไฟล์ต้นฉบับ) หากไม่ใช่กรณีที่สิ่งนี้กำลังถูกลบแม้ว่าจะมีการอ้างอิงตัวแปรมากขึ้นคุณสามารถลบการห่อหุ้มพร็อกซี

ดูเหมือนว่าวิธีสำนวนที่จะทำคือการให้close()วิธีการ (หรือคล้ายกัน) และเรียกมันอย่างชัดเจน