我建议使用Python的with语句来管理需要清理的资源。使用显式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将是Package类型的实例(它是__enter__方法返回的值)。不管是否发生异常，它的__exit__方法都会被自动调用。

您甚至可以进一步使用这种方法。在上面的例子中，有人仍然可以使用它的构造函数实例化Package而不使用with子句。你不会希望发生这种事的。你可以通过创建一个PackageResource类来修复这个问题，这个类定义了__enter__和__exit__方法。然后，Package类将在__enter__方法中严格定义并返回。这样，调用者不使用with语句永远不能实例化Package类:

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

只要用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变量(如果它被删除，那么它不会影响原始文件列表)。如果即使有更多对变量的引用，也没有删除该变量，那么可以删除代理封装。

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

标准的方法是使用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回答的附录，你可以使用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

我认为在__del__被调用之前，实例成员不可能被移除。我的猜测是，您的特定AttributeError的原因是在其他地方(可能您错误地删除了self。文件在其他地方)。

然而，正如其他人指出的那样，你应该避免使用__del__。主要原因是带有__del__的实例不会被垃圾收集(只有当它们的refcount达到0时才会被释放)。因此，如果你的实例涉及循环引用，那么只要应用程序运行，它们就会一直存在于内存中。(我可能对所有这些都错了，我必须再次阅读gc文档，但我相当肯定它是这样工作的)。