Python：删除自引用对象

Question

想问一下如何在Python中删除具有自引用的对象。

让我们考虑一个类，这是一个知道何时创建和何时删除的简单示例：

#!/usr/bin/python
class TTest:
  def __init__(self):
    self.sub_func= None
    print 'Created',self
  def __del__(self):
    self.sub_func= None
    print 'Deleted',self
  def Print(self):
    print 'Print',self

这个类有一个变量self.sub_func，我们假设给它分配一个函数。我想为self.sub_func 分配一个使用TTest 实例的函数。请看以下案例：

def SubFunc1(t):
  t.Print()
def DefineObj1():
  t= TTest()
  t.sub_func= lambda: SubFunc1(t)
  return t

t= DefineObj1()
t.sub_func()
del t

结果是：

Created <__main__.TTest instance at 0x7ffbabceee60>
Print <__main__.TTest instance at 0x7ffbabceee60>

也就是说，虽然我们执行了“del t”，但t并没有被删除。

我猜是因为 t.sub_func 是一个自引用对象，所以 t 的引用计数器不会在“del t”处变为零，因此 t 不会被垃圾收集器删除。

要解决这个问题，我需要插入

t.sub_func= None

在“del t”之前；此时，输出为：

Created <__main__.TTest instance at 0x7fab9ece2e60>
Print <__main__.TTest instance at 0x7fab9ece2e60>
Deleted <__main__.TTest instance at 0x7fab9ece2e60>

但这很奇怪。 t.sub_func 是 t 的一部分，所以我不想关心删除 t 时清除 t.sub_func。

如果你知道一个好的解决方案，你能告诉我吗？

Answer 1

如何确保引用循环中的对象在不再可访问时被删除？最简单的解决方案是不定义__del__ 方法。如果有的话，很少有类需要__del__ 方法。 Python 不保证何时甚至是否会调用 __del__ 方法。

有几种方法可以缓解这个问题。

1. 使用包含和检查弱引用的函数而不是 lambda。每次调用函数时都需要明确检查对象是否仍然存在。
2. 为每个对象创建一个唯一的类，以便我们可以将函数存储在一个类中，而不是作为猴子修补函数。这可能会占用大量内存。
3. 定义一个知道如何获取给定函数并将其转换为方法的属性。我个人最喜欢它，因为它非常近似于如何从类的未绑定方法创建绑定方法。

使用弱引用

import weakref

class TTest:
    def __init__(self):
        self.func = None
        print 'Created', self
    def __del__(self):
        print 'Deleted', self
    def print_self(self):
        print 'Print',self

def print_func(t):
    t.print_self()

def create_ttest():
    t = TTest()
    weak_t = weakref.ref(t)
    def func():
        t1 = weak_t()
        if t1 is None:
            raise TypeError("TTest object no longer exists")
        print_func(t1)
    t.func = func
    return t

if __name__ == "__main__":
    t = create_ttest()
    t.func()
    del t

创建一个独特的类

class TTest:
    def __init__(self):
        print 'Created', self
    def __del__(self):
        print 'Deleted', self
    def print_self(self):
        print 'Print',self

def print_func(t):
    t.print_self()

def create_ttest():
    class SubTTest(TTest):
        def func(self):
            print_func(self)
    SubTTest.func1 = print_func 
    # The above also works. First argument is instantiated as the object the 
    # function was called on.
    return SubTTest()

if __name__ == "__main__":
    t = create_ttest()
    t.func()
    t.func1()
    del t

使用属性

import types

class TTest:
    def __init__(self, func):
        self._func = func
        print 'Created', self
    def __del__(self):
        print 'Deleted', self
    def print_self(self):
        print 'Print',self
    @property
    def func(self):
        return types.MethodType(self._func, self)

def print_func(t):
    t.print_self()

def create_ttest():
    def func(self):
        print_func(self)
    t = TTest(func)
    return t

if __name__ == "__main__":
    t = create_ttest()
    t.func()
    del t

Answer 2

来自the official CPython docs：

具有__del__() 方法并且是引用循环的一部分的对象会导致整个引用循环无法收集，包括不一定在循环中但只能从中访问的对象。 Python 不会自动收集此类循环，因为通常 Python 无法猜测运行 __del__() 方法的安全顺序。如果您知道安全顺序，则可以通过检查垃圾列表来强制执行该问题，并根据列表中的对象显式中断循环。请注意，由于位于垃圾列表中，这些对象仍然保持活动状态，因此它们也应该从垃圾中删除。例如，在中断循环后，执行del gc.garbage[:] 以清空列表。通常最好通过不使用 __del__() 方法创建包含对象的循环来避免此问题，并且在这种情况下可以检查垃圾以验证没有创建此类循环。

另见：http://engineering.hearsaysocial.com/2013/06/16/circular-references-in-python/