赋值 Python 对象，会发生什么？

Question

如果我创建一个对象：

class eggs(object):
    """ This wasn't needed """

    def __setattr__(self, name, value):
        print name, value

如果我这样做，我可以理解：

class eggs(object):
    """ This wasn't needed """

    def __setattr__(self, name, value):
        print name, value


if __name__ == "__main__":
    foo = eggs()
    foo.bar = 5
    print foo

我明白了：

bar 5
<__main__.eggs object at 0x8f8bb0c>

但是当我这样做时：

if __name__ == "__main__":
    foo = eggs()
    foo = 5
    print foo

我明白了：

5

我的问题是调用foo = 5 时调用了什么“魔法”方法？

例如我这样做：

class eggs(object):
    """ This wasn't needed """
    def __init__(self):
        self.bacon = False

    def __setattr__(self, name, value):
        if not name == "bacon": 
            raise Exception("No way Hosay")
        if value not in [True, False]:
            raise Exception("It wasn't supposed to be like this")
        super(eggs, self).__setattr__(name, value)
        print "Variable became {0}".format(value)




if __name__ == "__main__":
    foo = eggs()
    foo.bacon = True
    foo.bacon = 5 > 4
    foo.bacon = True or False
    # ETC

返回：

Variable became False
Variable became True
Variable became True
Variable became True

我想不吃培根。

Answer 1

您误解了变量在 python 中的工作方式——它们只是对对象的引用，而重新赋值只是用另一个引用覆盖引用。

作为一个简化的解释，假设变量赋值的工作方式类似于分配字典的成员。如果我们称那个字典为variables，我们可以重写

foo = 5

作为

variables["foo"] = 5

现在，您希望 variables["foo"] 的 current 值（如果它甚至存在）被通知分配，这意味着前面的语句将类似于以下语句：

variables["foo"].__somemethod__() #call magic method to notify reassignment
variables["foo"] = 5 # set new value

虽然您实际上可以使用 dict 子类来实现这种精确的行为，但这根本不是 CPython 中变量赋值的实现方式。变量引用的对象不会以任何方式通知variables["foo"] 不再引用它。所发生的只是先前引用的对象（如果有的话）的引用计数减一。

正如 Stick 的回答所展示的，有一个 __del__ 方法在对象被垃圾收集时调用，这对于您的实际用例可能或可能不够。但是什么时候调用它实际上是由 gc 决定的，所以它可以表现出一些时髦的行为；参见例如this answer 讨论一些怪癖。此外，在 python3.4 之前，甚至无法保证在调用 __del__ 时任何引用的对象仍然存在，现在已修复此问题：http://legacy.python.org/dev/peps/pep-0442/。

如果您确实需要在引用被覆盖时收到通知（并且我怀疑没有更好的方法来解决您的实际问题），请考虑为您想要的所有引用使用子类或猴子补丁dict追踪。您需要覆盖 __setattr__ 方法来执行您希望在覆盖引用时发生的操作。

Answer 2

如果你想变得古怪，你可以覆盖__del__，但这通常是一整罐蠕虫。

>>> class A(object):
...     def __del__(self):
...             print "oh noooo!"
... 
>>> Stick = A()
>>> Stick = 5
oh noooo!
>>> Stick
5
>>> 

编辑：听起来您还想知道何时创建或删除对象？

也许只有一个装饰器就足够了？

>>> def talk(func):
...     def inner(*args, **kwargs):
...             print "I'm doing things!"
...             return func(*args, **kwargs)
...     return inner
... 
>>> class A(object):
...     @talk
...     def __init__(self):
...             pass
...     @talk
...     def __del__(self):
...             pass
... 
>>> Stick = A()
I'm doing things!
>>> del Stick
I'm doing things!
>>> Stick
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'Stick' is not defined
>>>

这适用于实例化和删除，以及变量的重新分配。

当然——如果你在调用__init__ 和__del__ 时需要不同的方法，你会想要使用不同的装饰器。只需将您的“实际工作”放在嵌套函数中即可。

def wrapper(func):
    def inner(*args, **kwargs):
        #your code here!
        #your code here as well!
        return func(*args, **kwargs)
    return inner

在与__del__ 混在一起时，请警惕傻瓜之类的东西，但我认为这是一种相对理智的做法。

Answer 3

你应该看看Descriptors，他们是最接近你想要的东西