我在 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__ 引用对我来说没有意义，因为实例的自引用方法应该被忽略(就像赋值之前一样)。

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

最佳答案

当您编写 a.a 时，它有效地运行:

A.a.__get__(a, A)

因为您不是在访问预绑定(bind)方法，而是正在访问的类方法 在运行时绑定(bind)。

当你做的时候

a.a = a.a

您有效地“缓存”了绑定(bind)方法的行为。由于绑定(bind)方法引用了对象(显然，因为它必须将 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()

您可以使用弱引用在 log_all_calls 中按需绑定(bind)，例如:

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。

关于python - 为什么要设置一个绑定(bind)方法给 python 对象创建一个循环引用？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26157952/