在 Python 中实现观察者模式的替代方法

Question

我正在浏览一篇关于如何在 Python 中实现观察者模式的文章。 在同一帖子中有这些评论。

1(在python中，你也可以只使用普通函数，"观察者" 类并不是真正需要的。

2(这是Java程序员曾经尝试做的事情的很好的例子 他们切换到Python——他们觉得Python缺少所有的废话 并尝试"移植"它。

这些注释意味着观察者模式在python中并不是真正有用，并且还有其他方法可以实现相同的效果。 这是真的吗，如果能怎么做？

以下是观察者模式的代码：

class Observable(object):
    def __init__(self):
        self.observers = []
    def register(self, observer):
        if not observer in self.observers:
            self.observers.append(observer)
    def unregister(self, observer):
        if observer in self.observers:
            self.observers.remove(observer)
    def unregister_all(self):
        if self.observers:
            del self.observers[:]
    def update_observers(self, *args, **kwargs):
        for observer in self.observers:
            observer.update(*args, **kwargs)
from abc import ABCMeta, abstractmethod
class Observer(object):
    __metaclass__ = ABCMeta
    @abstractmethod
    def update(self, *args, **kwargs):
        pass
class AmericanStockMarket(Observer):
    def update(self, *args, **kwargs):
        print("American stock market received: {0}n{1}".format(args, kwargs))
class EuropeanStockMarket(Observer):
    def update(self, *args, **kwargs):
        print("European stock market received: {0}n{1}".format(args, kwargs))

if __name__ == "__main__":
    observable = Observable()
    american_observer = AmericanStockMarket()
    observable.register(american_observer)
    european_observer = EuropeanStockMarket()
    observable.register(european_observer)
    observable.update_observers('Market Rally', something='Hello World')

Answer 1

在

python中，有许多不同的方法可以"观察"某些东西。使用属性描述符、自定义__setattr__、装饰器...

下面是一个使用第一类函数的简单示例：

class Foo(object):
    def __init__(self):
        self.observers = []
    def register(self, fn):
        self.observers.append(fn)
        return fn   # <-- See comments below answer
    def notify_observers(self, *args, **kwargs):
        for fn in self.observers:
            fn(*args, **kwargs)

然后，您可以注册任何可调用对象。

class Bar(object):
    def do_something(self, *args, **kwargs):
        pass # do something
foo = Foo()
bar = Bar()
foo.register(bar.do_something)

这将正常工作。对do_something的调用将具有正确的self值。因为对象的方法都是可调用的对象，这些对象带有对它们绑定到的实例的引用。

这可能有助于理解它在引擎盖下的工作原理：

>>> bar
<Bar object at 0x7f3fec4a5a58>
>>> bar.do_something
<bound method Bar.do_something of <Bar object at 0x7f3fec4a5a58>>
>>> type(bar.do_something)
<class 'method'>
>>> bar.do_something.__self__
<Bar object at 0x7f3fec4a5a58>

---

[编辑：装饰器示例]

您也可以使用我们上面定义的register方法作为装饰器，如下所示：

foo = Foo()
@foo.register
def do_something(*args, **kwargs):
    pass # do something

为此，请记住register需要返回它注册的可调用对象。