如何识别何时设置属性的属性？ - 虽然属性是一个对象列表

Question

我见过这个堆栈溢出问题： 链接。 我也想做同样的事情，但是如果可变属性是一个对象列表而不是一个对象呢？ 无论如何，该解决方案是否有效？ 问题是，有一个列表时，有时候我会喜欢做一些计算，当列表中的一个对象已被更改或当所有名单上的对象已经改变-问题是，如果所有的对象都改变了我不不想重复每个列表的项目正在改变时间计算，因为计算将是相同的，但在列表中的所有值已经改变了这将是唯一有效的。

例如，

我不想要这个：

Set element[0] -> computation -> set element[1] -> computation ... -> set element[n-1] -> computation

我要这个：

Set element[0] -> set element[1] -> set element[2] -> ... -> set element[n-1] -> computation

有可能做到这一点吗？ 同时，我将尝试在所附问题上使用代码，如果我有任何更新，我会通知您。

class Foomutable(object):
    def __init__(self):
        self.attr0 = 0
        self.attr1 = 1

class Foo(object):
    def __init__(self):
        self.mutable = [Foomutable()]*4
        
    def computation(self):
        sum = 0.0
        for mut in self.mutable:
            sum += mut.attr0 * mut.attr1
        return sum

    
    @property
    def mutable(self):
        return self._mutable

    @mutable.setter # Set attributes of mutable
    def mutable(self, attrs):
        # mutable is the list of objects
        # Here if one or all the objects in mutable change the value of their attributes then
        # do computation.
        self.computation()

目前改变 mutable 的方法是为每个元素循环改变它的一个或多个属性。

Answer 1

我认为解决这个问题的最好方法是让上下文管理器授予对可变对象的访问权限，并在上下文退出时进行计算。 这是一个简单的例子：

from contextlib import contextmanager
from typing import ContextManager, Iterator, List


class Foo:
    def __init__(self) -> None:
        self._mutable = [0, 1, 2, 3]
        self._total = sum(self._mutable)

    def computation(self) -> None:
        self._total = sum(self._mutable)
        print(f"* new computed total: {self._total}")

    @property
    def mutable(self) -> ContextManager[List[int]]:
        @contextmanager
        def context() -> Iterator[List[int]]:
            old = self._mutable.copy()
            try:
                yield self._mutable
            finally:
                if old != self._mutable:
                    print(f"* changed {old} to {self._mutable}, recomputing!")
                    self.computation()
        return context()


foo = Foo()
with foo.mutable as m:
    print(f"Current attributes: {m}")
    # no computation happens because we didn't change anything
with foo.mutable as m:
    print(f"Now we're going to change them...")
    m[0] = 10
    m[1] = 10
    m[2] = 10
    m[3] = 10
    # recomputation happens here!
with foo.mutable as m:
    print(f"All done!  {m}")

输出：

Current attributes: [0, 1, 2, 3]
Now we're going to change them...
* changed [0, 1, 2, 3] to [10, 10, 10, 10], recomputing!
* new computed total: 40
All done!  [10, 10, 10, 10]

在这个例子中，我只是使用List[int]作为可变对象； 您可以将此相同的通用技术应用于任何其他可变对象，包括可变对象列表，只要您可以在上下文管理器中正确实现比较，以确定是否有任何更改需要重新计算。

这是使用FooMutable类的同一示例的扩展版本。 请注意，为了进行比较，我们需要在FooMutable对象上实现__eq__ ，并且我们还需要确保我们正在深度复制这两个列表（否则“旧”列表只会引用相同的可变对象）。

from contextlib import contextmanager
from typing import ContextManager, Iterator, List


class FooMutable:
    def __init__(self) -> None:
        self.attr0 = 0
        self.attr1 = 1

    def __eq__(self, other: object) -> bool:
        return (
            isinstance(other, FooMutable)
            and self.__dict__ == other.__dict__
        )

    def __repr__(self) -> str:
        return f"<{'+'.join(map(str, self.__dict__.values()))}>"

    def copy(self) -> 'FooMutable':
        other = FooMutable()
        other.__dict__.update(self.__dict__)
        return other


class Foo:
    def __init__(self) -> None:
        self._mutable = [FooMutable() for _ in range(4)]
        self._total = 4

    def computation(self) -> None:
        self._total = sum(sum(m.__dict__.values()) for m in self._mutable)
        print(f"* new computed total: {self._total}")

    @property
    def mutable(self) -> ContextManager[List[FooMutable]]:
        @contextmanager
        def context() -> Iterator[List[FooMutable]]:
            old = [f.copy() for f in self._mutable]
            try:
                yield self._mutable
            finally:
                if old != self._mutable:
                    print(f"* changed {old} to {self._mutable}, recomputing!")
                    self.computation()
        return context()


foo = Foo()
with foo.mutable as m:
    print(f"Current attributes: {m}")
    # no computation happens because we didn't change anything
with foo.mutable as m:
    print(f"Now we're going to change them...")
    m[0].attr1 = 10
    m[1].attr1 = 10
    m[2].attr1 = 10
    m[3].attr1 = 10
    # recomputation happens here!
with foo.mutable as m:
    print(f"All done!  {m}")

请注意，我对FooMutable实现主要是传递到其__dict__ ； 如果它只是充当一个可变容器，那么将它变成一个TypedDict或类似的容器会更容易，其中所有这些方法都已经实现。