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

Question

我见过这个堆栈溢出问题：link。我也想做同样的事情，但是如果可变属性是一个对象列表而不是一个对象呢？无论如何，该解决方案会起作用吗？问题是当有一个列表时，有时我想在列表的一个对象已更改或列表中的所有对象已更改时进行一些计算 - 问题是如果所有对象都已更改，我 不想希望每次更改列表中的项目时都重复计算，因为计算将是相同的，但只有当列表的所有值都更改时才有效。 p>

例如，

我不想要这个：

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 或已实现所有这些方法的类似容器会更容易。