python - 组成:为什么 "container instance"改变时 "contained instance"属性没有更新？

Question

我想更好地理解容器对象属性和包含对象属性之间的关系。

我想了解这个例子的输出:

我创建了一个类 Car 和一个类 Tire。
Tire 也有一个属性 age，它应该“指向”名为 bmw 的汽车实例的属性。 所以我认为通过改变 bmw 实例的属性，倍耐力属性 age 也应该更新，因为它引用了同一个变量。从示例中可以看出，情况并非如此。

我该怎么做才能真正更新它？ 我计划多次使用合成，所以在最后一个类中使用

是非常不切实际的

finalInstance.age = previousInstances.tire.car.age。

class Car:
    def __init__(self, age):
        self.age = age

class Tire:
    def __init__(self, car):
        self.car = car
        self.age = self.car.age

bmw = Car(age=1)
print('Car age is ',bmw.age)

pirelli = Tire(car=bmw)
print('Tire age is ',pirelli.age)

bmw.age = 2
print('Car age is now ',bmw.age)
print('Tire age is now ',pirelli.age)

我期望这样的输出:

Car age is  1
Tire age is  1
Car age is now  2
Tire age is now  2

但我得到的是:

Car age is  1
Tire age is  1
Car age is now  2
Tire age is now  1

谁能帮我想办法让轮胎的 self.age = self.car.age 自动更新？

非常感谢。

Answer 1

Python 中的赋值运算符 = 实际上改变了赋值给指向的对象。

换句话说，在您的示例中，当该行已运行。当您稍后运行 bmw.age = 2 更改汽车类中的属性时 - 它指向一个新对象。但是 bmw.car.age 没有改变。

您必须首先了解这一点，简单明了的事情就是使用，即使在 Tire 类中，属性 self.car 的完整路径。年龄。

然后，如果您真的认为您需要动态更改属性，我们必须求助于“响应式(Reactive)”编程 - 一种状态更改自动传播到代码中其他位置的方法。 Python 允许以多种方式实现这一点。示例如下。

因此，Python 处理此类事情的强大机制之一是“descriptor protocol”——该语言指定如果一个对象绑定(bind)为类属性——也就是说，在 类中定义 主体，不仅在 __init__ 或其他方法内 - 具有 __get__ 方法(或其他几个特殊命名方法)，检索或尝试重新绑定(bind)(使用=) 该类实例中的该属性将通过该类中的该对象。它被称为“描述符”。

Python 的 property 装饰器使用这种机制来提供为属性创建 setter 和 getter 的最常用案例。但是由于您需要对许多相似的属性使用相同的访问和获取规则，因此创建一个专门的描述符类更有意义——它将“知道”属性的来源，并且总是去它的来源获取或设置它的值(value)。

下面的代码以及“汽车、轮胎和螺丝”类提供了一个示例:

class LinkedAttribute:
    def __init__(self, container_path):
        self.container_path = container_path

    def __set_name__(self, owner, name):
        self.name = name

    def _get_container(self, instance):
        container = instance
        for component in self.container_path.split("."):
            container = getattr(container, component)
        return container

    def __get__(self, instance, owner):
        if instance is None:
            return self
        container = self._get_container(instance)
        return getattr(container, self.name)

    def __set__(self, instance, value):
        container = self._get_container(instance)
        setattr(container, self.name, value)



class Car:
    def __init__(self, age):
        self.age = age

class Tire:
    age = LinkedAttribute("car")

    def __init__(self, car):
        self.car = car
        self.age = self.car.age

class Screw:
    age = LinkedAttribute("tire.car")

    def __init__(self, tire):
        self.tire = tire

在交互式解释器中我们有:

In [37]: bmw = Car(2) 
    ...:                                                                                     

In [38]: t1 = Tire(bmw) 
    ...:                                                                                     

In [39]: s1 = Screw(t1)                                                                      

In [40]: t1.age                                                                              
Out[40]: 2

In [41]: bmw.age = 5                                                                         

In [42]: t1.age                                                                              
Out[42]: 5

In [43]: s1.age                                                                              
Out[43]: 5

In [44]: s1.age = 10                                                                         

In [45]: bmw.age                                                                             
Out[45]: 10

当然，如果您不想允许从包含的类中修改任何父属性，只需在 __set__ 方法上省略(或放置一个保护标志) .