如何触发价值变化的功能？

Question

我意识到这个问题与事件处理有关，并且我已经阅读了有关 Python 事件处理程序和调度程序的信息，因此要么它没有回答我的问题，要么我完全错过了信息。

我希望在值v 发生变化时触发对象A 的方法m()：

例如（假设金钱使人快乐）：

global_wealth = 0

class Person()
    def __init__(self):
        self.wealth = 0
        global global_wealth
        # here is where attribute should be
        # bound to changes in 'global_wealth'
        self.happiness = bind_to(global_wealth, how_happy)

    def how_happy(self, global_wealth):
        return self.wealth / global_wealth

因此，无论何时更改 global_wealth 值，Person 类的所有实例都应相应更改其 happiness 值。

NB：我不得不编辑这个问题，因为第一个版本似乎表明我需要 getter 和 setter 方法。很抱歉造成混乱。

Answer 1

您需要使用Observer Pattern。 在以下代码中，一个人订阅接收来自全球财富实体的更新。当全球财富发生变化时，该实体会提醒其所有订阅者（观察者）发生变化。 Person 然后更新自己。

我在这个例子中使用了属性，但它们不是必需的。一个小警告：属性仅适用于新样式类，因此类声明后的 (object) 是强制性的。

class GlobalWealth(object):
    def __init__(self):
        self._global_wealth = 10.0
        self._observers = []

    @property
    def global_wealth(self):
        return self._global_wealth

    @global_wealth.setter
    def global_wealth(self, value):
        self._global_wealth = value
        for callback in self._observers:
            print('announcing change')
            callback(self._global_wealth)

    def bind_to(self, callback):
        print('bound')
        self._observers.append(callback)


class Person(object):
    def __init__(self, data):
        self.wealth = 1.0
        self.data = data
        self.data.bind_to(self.update_how_happy)
        self.happiness = self.wealth / self.data.global_wealth

    def update_how_happy(self, global_wealth):
        self.happiness = self.wealth / global_wealth


if __name__ == '__main__':
    data = GlobalWealth()
    p = Person(data)
    print(p.happiness)
    data.global_wealth = 1.0
    print(p.happiness)

Answer 2

如果你想在属性改变时执行代码，你可以使用属性。请注意，更改属性时发生的巨大副作用或显着开销对于使用您的 API 的任何人来说都有些令人惊讶，因此在某些情况下，您可能希望通过使用方法来避免它。

class A(object):

    def m(self, p_value):
         print p_value

    @property
    def p(self):
        return self._p 

    @p.setter
    def p(self, value)
        self._p = value
        self.m(value)

Answer 3

你在寻找什么叫做 (Functional) Reactive Programming。 对于 Common Lisp，有 Cells - 请参阅 Cells project 和 Cells manifesto，对于 python，有 Trellis library。

电子表格也使用相同的范例。对于跟踪多个相互关联的参数非常有用——例如在 GUI 编程中。

响应式编程类似于观察者模式，但有一个重要区别：

与观察者模式的相似之处 但是，将数据流概念集成到编程语言中会使它们更容易表达，因此可以增加数据流图的粒度。例如，观察者模式通常描述整个对象/类之间的数据流，而面向对象的反应式编程可以针对对象/类的成员。

Answer 4

你需要一个property

class MyClass(object):
    def __init__(self):
        self._x = None

    def x_setter(self, value):
        self._x = value

    def x_getter(self):
        return self._x

    x = property(x_getter, x_setter)

在这里，每当你想设置 x MyClass().x = "foo" 时，你都会使用 x_getter 方法 并且每当您想检索 x print MyClass().x时，您将使用 x_setter 方法。

Answer 5

你可以试试这样的：

class Variable:
    def __init__(self, v):
        self.v=v
        self.command=None
    def set(self, v):
        self.v=v
        if self.command!=None:
            self.command()
    def get(self):
        return self.v
    def trace(self, command):
        self.command=command

x=Variable(0)

def money():
    amount="{:.2f}".format(x.get())
    print("You have $"+amount+".")

x.trace(money)

x.set(5.55)
x.set(15.14)

如果您需要参数，只需使用 lambda 函数。鉴于此（以及我最近更彻底地研究过的公认答案），这里有一个更复杂的版本，包含 cmets、更多功能和示例：

class Variable: #This is a class for the variable you want to bind something to
    def __init__(self, v):
        self.v=v
        self.commands=[]
    def set(self, v): #Set the variable's value and call any bound functions
        self.v=v
        for x in self.commands:
            x()
    def get(self): #Get the variable's value
        return self.v
    def trace(self, *commands): #Bind one or more functions to the variable
        for x in commands:
            if x in self.commands:
                raise ValueError("You can’t add the same command object twice. If you need to, use another lambda function that calls the same function with the same parameters.")
        self.commands.extend(commands)
    def untrace(self, *commands): #Unbind one or more functions from the variable
        for x in commands:
            if x not in self.commands:
                raise ValueError(str(x)+" is not a traced command.")
        for x in commands:
            if x in self.commands:
                self.commands.remove(x)
    def clear_traces(self): #Removes all functions bound to the variable
        self.commands.clear()

x=Variable(0) #Make the variable, starting with a value of 0

def money(name): #Define the method to bind
    amount="{:.2f}".format(x.get())
    print(name+" has $"+amount+".")

sam=lambda : money("Sam") #We're making a new method to bind that calls the old one with the argument "Sam"
sally=lambda : money("Sally") #Another one (Sally and Sam will always have the same amount of money while they are both bound to the variable.)

#Bind them both to the value (not that this is practical, but we're doing both for demonstration)
x.trace(sam)
x.trace(sally)

#Set the value
x.set(5.55)
#Unbind the sam lambda function and set the value again
x.untrace(sam)
x.set(15.14)

"""
This prints the following:
> Sam has $5.55.
> Sally has $5.55.
> Sally has $15.14.
"""

另类

不管怎样，你也可以使用Tkinter自带的内置功能，比如DoubleVar.trace()或者someWidget.wait_variable()。

trace() 方法允许您将方法绑定到 StringVar、IntVar、FloatVar、DoubleVar、BooleanVar 或此类变量。这是一个完整的 Python 3.x 示例：

from tkinter import *

tk=Tk()
tk.withdraw()

d=DoubleVar(master=tk, value=0)

def my_event_handler(*args):
    amount="{:.2f}".format(d.get())
    print("$"+amount)

d.trace(mode="w", callback=my_event_handler)

d.set(5.55)
d.set(15.12)

"""
This prints the following:
> You have $5.55.
> You have $15.12.
"""

您可能希望在程序结束时销毁 Tk 对象。但是，在我的示例中，如果没有它，它似乎可以正常退出。

wait_variable() 是另一种替代方法，它会导致调用函数停止而不停止 GUI，直到您指定的变量发生更改。还有其他类似的方法。