为什么要为python对象设置绑定方法创建循环引用？

Question

我正在Python 2.7中工作，我喜欢那个让我困惑的问题。

这是最简单的例子：

>>> class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

>>> a = A() 
>>> del a 
DEL 

这是确定的预期一样......我现在试图改变对象a的a()方法，什么发生的是更改后它，我不能删除a更多：

>>> a = A() 
>>> a.a = a.a 
>>> del a 

只是做一些检查，我之前和分配之后打印a.a参考

>>> a = A() 
>>> print a.a 
<bound method A.a of <__main__.A object at 0xe86110>> 
>>> a.a = a.a 
>>> print a.a 
<bound method A.a of <__main__.A object at 0xe86110>> 

最后我用objgraph模块，试图理解为什么对象没有被释放：

>>> b = A() 
>>> import objgraph 
>>> objgraph.show_backrefs([b], filename='pre-backref-graph.png') 

>>> b.a = b.a 
>>> objgraph.show_backrefs([b], filename='post-backref-graph.png') 

正如你可以在post-backref-graph.png图像有见是b中的__self__引用，因为自我r对我没有意义实例方法的推断应该被忽略（就像在赋值之前那样）。

有人可以解释为什么这种行为，我该如何解决它？

Answer 1

当你写a.a，它有效地运行：

A.a.__get__(a, A) 

因为你没有访问预结合的方法，但类的方法正被 势必在运行时。

当你

a.a = a.a 

你有效的“缓存”的结合方法的行为。由于绑定方法具有对象的引用（显然，因为它必须将self传递给该函数），因此会创建一个循环引用。

---

所以我喜欢建模您的问题：

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls(function): 
    def inner(*args, **kwargs): 
     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls(a.a) 

a.a() 

您可以使用弱引用按需绑定内lof_all_calls，如：

import weakref 

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls_weakmethod(method): 
    cls = method.im_class 
    func = method.im_func 
    instance_ref = weakref.ref(method.im_self) 
    del method 

    def inner(*args, **kwargs): 
     instance = instance_ref() 

     if instance is None: 
      raise ValueError("Cannot call weak decorator with dead instance") 

     function = func.__get__(instance, cls) 

     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls_weakmethod(a.a) 

a.a() 

这实在是太丑了，所以我宁愿抽出来做一个weakmethod装饰：

import weakref 

def weakmethod(method): 
    cls = method.im_class 
    func = method.im_func 
    instance_ref = weakref.ref(method.im_self) 
    del method 

    def inner(*args, **kwargs): 
     instance = instance_ref() 

     if instance is None: 
      raise ValueError("Cannot call weak method with dead instance") 

     return func.__get__(instance, cls)(*args, **kwargs) 

    return inner 

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls(function): 
    def inner(*args, **kwargs): 
     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls(weakmethod(a.a)) 

a.a() 

完成！

---

FWIW，不仅是Python 3。4没有这些问题，它也有为您预制的WeakMethod。

Answer 2

Veedrac关于保持引用实例的绑定方法的答案只是答案的一部分。 CPython中的垃圾回收器知道如何检测和处理循环引用 - 除非某些对象是周期的一部分具有__del__方法，如下https://docs.python.org/2/library/gc.html#gc.garbage提到：有__del__()方法，是一个参考周期 的一部分

对象导致整个参考周期无法收集，包括 对象不一定在循环中，但只能从循环中访问。 Python不会自动收集这些循环，因为一般而言， Python不可能猜测运行方法的安全顺序。 （...）通常情况下，最好避免使用__del__()方法创建包含对象的循环，在这种情况下可以检查 垃圾，以验证没有创建这样的循环 。

IOW：删除您的__del__方法，你应该没问题。

编辑：WRT /您的评论：

我用它的对象为功能a.a = functor(a.a)。当测试 完成后，我想用原来的方法替换函子。

然后将溶液是简单明了：

a = A() 
a.a = functor(a.a) 
test(a) 
del a.a 

除非你明确地将其绑定，a已经没有“A”的实例属性附加伤害，所以它抬头的类并返回一个新的method实例（请参阅https://wiki.python.org/moin/FromFunctionToMethod了解更多信息）。然后这个method实例被调用，并且（通常）被丢弃。

Answer 3

至于为什么Python这样做。技术上全部对象包含循环引用，如果他们有方法。但是，如果垃圾收集器必须对对象方法进行显式检查以确保释放对象不会导致问题，则垃圾收集将花费更长时间。像这样Python将方法与对象的__dict__分开存储。因此，当您编写a.a = a.a时，您在该对象的a字段中使用了自己的方法。因此，对于防止对象被正确释放的方法有明确的参考。

问题的解决方案并不打算保留原始方法的“缓存”，只需在完成后删除阴影变量。这将淡化该方法并使其再次可用。

>>> class A(object): 
...  def __del__(self): 
...   print("del") 
...  def method(self): 
...   print("method") 
>>> a = A() 
>>> vars(a) 
{} 
>>> "method" in dir(a) 
True 
>>> a.method = a.method 
>>> vars(a) 
{'method': <bound method A.method of <__main__.A object at 0x0000000001F07940>>} 
>>> "method" in dir(a) 
True 
>>> a.method() 
method 
>>> del a.method 
>>> vars(a) 
{} 
>>> "method" in dir(a) 
True 
>>> a.method() 
method 
>>> del a 
del 

这里vars显示了在一个对象的属性__dict__。请注意0​​如何不包含对自身的引用，即使a.__dict__有效。 dir产生从给定对象可到达的所有属性的列表。在这里，我们可以看到对象上的所有属性和方法以及它的类和它们的基础的所有方法和属性。这表明a的绑定方法被存储在独立于a的属性存储位置。