一个好主意是将两种方法结合起来。

实现用于显式生命周期处理的上下文管理器。以及句柄清理，以防用户忘记它或不方便使用with语句。这最好由weakref.finalize来完成。

这是很多图书馆实际做的。根据严重程度，你可以发出警告。

它保证只被调用一次，所以在之前的任何时候调用它都是安全的。

import os
from typing import List
import weakref

class Package:
    def __init__(self):
        self.files = []
        self._finalizer = weakref.finalize(self, self._cleanup_files, self.files)

    @staticmethod
    def _cleanup_files(files: List):
        for file in files:
            os.unlink(file)

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._finalizer()

weakref。Finalize返回一个可调用的终结器对象，该对象将在obj被垃圾收集时被调用。与普通的弱引用不同，终结器将始终存在，直到引用对象被收集，从而极大地简化了生命周期管理。”

不像atexit。寄存器对象在解释器关闭之前不会保存在内存中。

不像物体。__del__ weakref。Finalize保证在解释器关闭时被调用。所以更安全。

下面是一个最小的工作框架:

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

重要:返回自我

如果你像我一样，忽略了(克林特·米勒正确答案中的)“回归自我”部分，你将会看到下面这段废话:

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

希望它能帮助到下一个人。

只要用try/except语句包装你的析构函数，如果你的全局变量已经被处理了，它就不会抛出异常。

Edit

试试这个:

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

它会将文件列表填充到del函数中，该函数保证在调用时存在。weakref代理是为了防止Python或您自己删除self。Files变量(如果它被删除，那么它不会影响原始文件列表)。如果即使有更多对变量的引用，也没有删除该变量，那么可以删除代理封装。

一个好主意是将两种方法结合起来。

实现用于显式生命周期处理的上下文管理器。以及句柄清理，以防用户忘记它或不方便使用with语句。这最好由weakref.finalize来完成。

这是很多图书馆实际做的。根据严重程度，你可以发出警告。

它保证只被调用一次，所以在之前的任何时候调用它都是安全的。

import os
from typing import List
import weakref

class Package:
    def __init__(self):
        self.files = []
        self._finalizer = weakref.finalize(self, self._cleanup_files, self.files)

    @staticmethod
    def _cleanup_files(files: List):
        for file in files:
            os.unlink(file)

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._finalizer()

weakref。Finalize返回一个可调用的终结器对象，该对象将在obj被垃圾收集时被调用。与普通的弱引用不同，终结器将始终存在，直到引用对象被收集，从而极大地简化了生命周期管理。”

不像atexit。寄存器对象在解释器关闭之前不会保存在内存中。

不像物体。__del__ weakref。Finalize保证在解释器关闭时被调用。所以更安全。

作为Clint回答的附录，你可以使用contextlib.contextmanager简化PackageResource:

@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):
        ...

简单地使用Package(…)作为Package。

为了更简洁，请将清理函数命名为close并使用contextlib。关闭，在这种情况下，你可以使用未修改的Package类via 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

更好的替代方法是使用weakref.finalize。请参阅终结器对象和用__del__()方法比较终结器的示例。