Python事件驱动模式简单理解

所有的计算机程序都可以大致分为两类：脚本型（单次运行）和连续运行型（直到用户主动退出）。
（1）脚本型：脚本型的程序包括最早的批处理文件以及使用Python做交易策略回测等等，这类程序的特点是在用户启动后会按照编程时设计好的步骤一步步运行，所有步骤运行完后自动退出。
（2） 连续运行型：连续运行型的程序包含了操作系统和绝大部分我们日常使用的软件等等，这类程序启动后会处于一个无限循环中连续运行，直到用户主动退出时才会结束。
我们要开发的交易系统就是属于连续运行型程序，而这种程序根据其计算逻辑的运行机制不同，又可以粗略的分为时间驱动和事件驱动两种。

1.1 时间驱动

时间驱动的程序逻辑相对容易设计，简单来说就是让电脑每隔一段时间自动做一些事情。这个事情本身可以很复杂、包括很多步骤，但这些步骤都是线性的，按照顺序一步步执行下来。
时间驱动的程序本质上就是每隔一段时间固定运行一次脚本。尽管脚本自身可以很长、包含非常多的步骤，但是我们可以看出这种程序的运行机制相对比较简单、容易理解。
时间驱动的程序在量化交易方面还存在一些其他的缺点：如浪费CPU的计算资源、实现异步逻辑复杂度高等等。

import time


def demo():
    print('do some thing ... ')


while True:
    demo()
    time.sleep(1.0)

1.2 事件驱动

与时间驱动对应的就是事件驱动的程序：当某个新的事件被推送到程序中时，程序立即调用和这个事件相对应的处理函数进行相关的操作。
举个例子：有些人喜欢的某个公众号，然后去关注这个公众号，哪天这个公众号发布了篇新的文章，没多久订阅者就会在微信里收到这个公众号推送的新消息，如果感兴趣就打开来阅读。
上面公众号例子可以翻译为，监听器（订阅者）监听了（关注了）事件源（公众号），当事件源的发送事件时（公众号发布文章），所有监听该事件的监听器（订阅者）都会接收到消息并作出响应（阅读文章）。
公众号为事件源订阅者为事件监听器订阅者关注公众号，相当于监听器监听了事件源公众号发布文章这个动作为发送事件订阅者收到事件后，做出阅读文章的响应动作。
事件驱动主要包含以下元素和操作函数：

1.2.1 元素

事件源
事件监听器
事件对象

1.2.2 操作函数

监听动作
发送事件
调用监听器响应函数
举例代码实现公众号订阅：

import time
from queue import Queue, Empty
from threading import *


class Event:
    """事件"""
    def __init__(self, type_=None):
        self.type_ = type_      # 事件类型
        self.dict = {}          # 字典用于保存具体的事件数据


class EventManager:
    """事件管理器"""
    def __init__(self):
        # 事件对象列表 可以使用队列或者是列表
        self.__eventQueue = Queue()
        # 事件管理器开关
        self.__active = False
        # 事件处理线程
        self.__thread = Thread(target=self.__run)
        # count 变量是用来便于观察执行的顺序
        self.count = 0
        # 这里的__handlers是一个字典，用来保存对应的事件的响应函数 其中每个键对应的值是一个列表，列表中保存了对该事件监听的响应函数，一对多
        self.__handlers = {}

    def __run(self):
        print('{}_run'.format(self.count))
        while self.__active is True:
            try:
                event = self.__eventQueue.get(block=True, timeout=1)
                self.__event_process(event)
            except Empty:
                pass
            self.count += 1

    def __event_process(self, event):
        """依次执行注册了回调"""
        print('{}_EventProcess'.format(self.count))
        # 检查是否存在对该事件进行监听的处理函数
        if event.type_ in self.__handlers:
            # 若存在，则按顺序将事件传递给处理函数执行
            for handler in self.__handlers[event.type_]:
                handler(event)
        self.count += 1

    def start(self):
        print('{}_Start'.format(self.count))
        # 将事件管理器设为启动
        self.__active = True
        # 启动事件处理线程
        self.__thread.start()
        self.count += 1

    def stop(self):
        """停止"""
        print('{}_Stop'.format(self.count))
        # 将事件管理器设为停止
        self.__active = False
        # 等待事件处理线程退出
        self.__thread.join()
        self.count += 1

    def add_event_listener(self, type_, handler):
        """绑定事件和监听器处理函数"""
        print('{}_AddEventListener'.format(self.count))

        # 尝试获取该事件类型对应的处理函数列表，若无则创建
        try:
            handlerList = self.__handlers[type_]
        except KeyError:
            handlerList = []

        self.__handlers[type_] = handlerList
        # 若要注册的处理器不在该事件的处理器列表中，则注册该事件
        if handler not in handlerList:
            handlerList.append(handler)
        print(self.__handlers)
        self.count += 1

    def remove_event_listener(self, type_, handler):
        """移除监听器的处理函数"""
        print('{}_RemoveEventListener'.format(self.count))
        try:
            handlerList = self.__handlers[type_]
            # 如果该函数存在于列表中，则移除
            if handler in handlerList:
                handlerList.remove(handler)
            # 如果函数列表为空，则从引擎中移除该事件类型
            if not handlerList:
                del self.__handlers[type_]
        except KeyError:
            pass
        self.count += 1

    def send_event(self, event):
        """向队列中存入事件 """
        print('{}_SendEvent'.format(self.count))
        self.__eventQueue.put(event)
        self.count += 1


# 时间名称 新文章
EVENT_ARTICAL = "Event_Artical"


# 事件源 公众号
class PublicAccounts:
    def __init__(self, eventManager):
        self.__eventManager = eventManager

    def write_newartical(self):
        # 事件对象 写了新文章
        event = Event(type_=EVENT_ARTICAL)
        # 事件数据
        event.dict["artical"] = u'如何写出更优雅的代码\n'
        # 发送事件
        self.__eventManager.send_event(event)
        print(u'公众号发送新文章\n')


class Listener:
    # 监听器 订阅者
    def __init__(self, username):
        self.__username = username

    def read_artical(self, event):
        # 监听器的处理函数 读文章
        print(u'%s 收到新文章' % self.__username)
        print(u'正在阅读新文章内容：%s' % event.dict["artical"])


def have_a_test():
    # 实例化监听器
    listner1 = Listener("thinkroom")  # 订阅者1
    listner2 = Listener("steve")      # 订阅者2

    # 实例化事件操作函数
    event_manager = EventManager()

    # 绑定事件和监听器响应函数(新文章)
    event_manager.add_event_listener(EVENT_ARTICAL, listner1.read_artical)
    event_manager.add_event_listener(EVENT_ARTICAL, listner2.read_artical)
    # 启动事件管理器
    event_manager.start()

    publicAcc = PublicAccounts(event_manager)

    # Timer(2, publicAcc.WriteNewArtical).start()

    for i in range(10):
        publicAcc.write_newartical()
        time.sleep(10)

    event_manager.stop()


if __name__ == '__main__':
    have_a_test()

转载

转自

https://blog.csdn.net/brucewong0516/article/details/84031715

有部分修改。