精华内容
下载资源
问答
  • 一个简单的 Python 事件循环 项目 这就像多线程,但一切都发生在同一个线程上 大多数时候,我想异步地做事,这是因为我希望我的程序在等待外部事物(如网络请求或计时器)时对其他事情保持有用,而不是因为我需要它...
  • 一个简单的Python 3.5+事件总线。 目的 一种触发多个后续功能的方法。 安装 pip3 install event-bus 用法 EventBus是在整个应用程序中使用的单例。 from event_bus import EventBus bus = EventBus () @ bus . on...
  • 主要为大家详细介绍了python事件驱动event实现,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python 事件驱动系统 目录 事件命名规则 带参数的事件 计时器 状态 州议员 状态层次结构 国家所有者 状态机 国家过渡 分层有限状态机 (HFSM) 来源 其他链接 介绍 该软件包提供了一种有效地手动编写有限状态机 (FSM...
  • python 事件处理

    2019-06-25 17:48:41
    一、概述 一个 GUI 应用整个生命周期都处在一个消息循环 (eventloop) 中。 它等待事件的发生, 并作出...如果相关事件发生, handler 函数会被触发 , 事件对象event 会传递给 handler 函数。二 二、鼠标和键盘事件...

    一、概述
    一个 GUI 应用整个生命周期都处在一个消息循环 (eventloop) 中。 它等待事件的发生, 并作出相应的处理。Tkinter 提供了用以处理相关事件的机制. 处理函数可被绑定给各个控件的各种事件。
    widget.bind(event, handler)
    如果相关事件发生, handler 函数会被触发 , 事件对象event 会传递给 handler 函数。二
    二、鼠标和键盘事件
    在这里插入图片描述
    三、event 对象常用属性
    在这里插入图片描述
    四、鼠标事件和键盘事件用法测试

    #coding=utf-8
    
    from tkinter import *
    
    class application(Frame):
        def __init__(self,master):
            super().__init__(master)
            self.master=master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            self.canvas = Canvas(self,width=200,height=200,bg='green')
            self.canvas.pack()
    
            self.canvas.bind('<Button-1>',self.mouseTest)
            self.canvas.bind('<B1-Motion>',self.test_drag)
            self.canvas.bind('<KeyPress>',self.keyboard_test)
            self.canvas.bind('<KeyPress-a>',self.press_a_test)
            self.canvas.bind('KeyRelease-a',self.release_a_test)
        def mouseTest(self,event):
            print('鼠标左键单机位置(相对于父容器):{0},{1}'.format(event.x,event.y))
            print('鼠标左键单击位置(相对于屏幕):{0},{1}'.format(event.x_root,event.y_root))
            print('事件绑定组件:{0}'.format(event.widget))
        def test_drag(self,event):
            self.canvas.create_oval(event.x,event.y,event.x+1,event.y+1)
    
        def keyboard_test(self,event):
            print('键的keycode:{0},char:{1},keysym:{2}'.format(event.keycode,event.char,event.keysym))
    
        def press_a_test(self,event):
            print('press a')
        def release_a_test(self):
            print('release a')
    
    
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry('500x300')
        app=application(root)
        root.mainloop()
    
    
    
    展开全文
  • Python 事件监听

    万次阅读 2017-10-08 17:20:38
    import tkinter def call(event): print(event.x,event.y) win=tkinter.Tk() frame=tkinter.Frame(win,width=200,height=200) frame.bind("",call) #触发的函数,可以用于监控当前窗口的位置 ...
    import tkinter
    def  call(event):
        print(event.x,event.y)
    
    win=tkinter.Tk()
    frame=tkinter.Frame(win,width=200,height=200) 
    frame.bind("<Motion>",call) #触发的函数,可以用于监控当前窗口的位置
    frame.pack()
    win.mainloop()
    
    

    展开全文
  • pulsar:事件驱动的并发框架
  • Sequential Event Experiment based on Travel note crawled from XieCheng,基于50W携程出行游记的采集与顺承事件图谱构建
  • python实现事件驱动

    2020-09-19 22:35:10
    主要为大家详细介绍了python实现事件驱动的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了python模拟事件触发机制的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 理解Python事件驱动编程(Event Loop)

    千次阅读 2017-09-11 17:42:12
    2年前我学习Python的时候只知道并发编程模型只有多进程和多线程,这两个模型的特点都是交由操作系统调度,无法人为控制,而且短板很明显,上下文切换和创建开销都是问题。后来又听说了Python的协程-用户级线程,可以...

      2年前我学习Python的时候只知道并发编程模型只有多进程和多线程,这两个模型的特点都是交由操作系统调度,无法人为控制,而且短板很明显,上下文切换和创建开销都是问题。后来又听说了Python的协程-用户级线程,可以人为调度,虽然轻量,但是本质上都是利用多个worker避免一个worker带来的阻塞问题。后来接触到Tornado,知道了Python的异步编程,号称单线程异步高性能web服务器。那个时候我一直有个疑问,既然是单线程,它是怎么做到这么高性能的,是不是内部在TCP层优化了,或者是利用了TCP层的什么复用技术。再后来我知道Tornado里面有个event loop的概念,由此我终于知道了事件驱动编程,Python所谓异步编程的真正面目。

      想要理解Python的事件驱动编程,就必须首先理解Python的协程、yield、以及IO多路复用(select、poll、epoll三件套)。但是我们还是要分两种场景来说明,一种是作为服务端,另一种是作为客户端。作为服务端,event loop最核心的就是IO多路复用技术(不懂的话可以自行百度),所有来自客户端的请求都由IO多路复用函数来处理,我觉得这个决定了Python的异步编程并不是真正的异步,在select返回准备好了的事件,依然是轮询处理,只要其中一个事件阻塞了,也会阻塞其他事件。

    展示下tornado的源码,只看中文的注释,其他细节先不管,太复杂了

     

    while True:
        # Prevent IO event starvation by delaying new callbacks
        # to the next iteration of the event loop.
        with self._callback_lock:
            callbacks = self._callbacks
            self._callbacks = []
    
        # Add any timeouts that have come due to the callback list.
        # Do not run anything until we have determined which ones
        # are ready, so timeouts that call add_timeout cannot
        # schedule anything in this iteration.
        due_timeouts = []
        if self._timeouts:
            now = self.time()
            while self._timeouts:
                if self._timeouts[0].callback is None:
                    # The timeout was cancelled.  Note that the
                    # cancellation check is repeated below for timeouts
                    # that are cancelled by another timeout or callback.
                    heapq.heappop(self._timeouts)
                    self._cancellations -= 1
                elif self._timeouts[0].deadline <= now:
                    due_timeouts.append(heapq.heappop(self._timeouts))
                else:
                    break
            if (self._cancellations > 512
                    and self._cancellations > (len(self._timeouts) >> 1)):
                # Clean up the timeout queue when it gets large and it's
                # more than half cancellations.
                self._cancellations = 0
                self._timeouts = [x for x in self._timeouts
                                  if x.callback is not None]
                heapq.heapify(self._timeouts)
    
        for callback in callbacks:
            self._run_callback(callback)
        for timeout in due_timeouts:
            if timeout.callback is not None:
                self._run_callback(timeout.callback)
        # Closures may be holding on to a lot of memory, so allow
        # them to be freed before we go into our poll wait.
        callbacks = callback = due_timeouts = timeout = None
    
        if self._callbacks:
            # If any callbacks or timeouts called add_callback,
            # we don't want to wait in poll() before we run them.
            poll_timeout = 0.0
        elif self._timeouts:
            # If there are any timeouts, schedule the first one.
            # Use self.time() instead of 'now' to account for time
            # spent running callbacks.
            poll_timeout = self._timeouts[0].deadline - self.time()
            poll_timeout = max(0, min(poll_timeout, _POLL_TIMEOUT))
        else:
            # No timeouts and no callbacks, so use the default.
            poll_timeout = _POLL_TIMEOUT
    
        if not self._running:
            break
    
        if self._blocking_signal_threshold is not None:
            # clear alarm so it doesn't fire while poll is waiting for
            # events.
            signal.setitimer(signal.ITIMER_REAL, 0, 0)
    
        try:
            # 监听事件
            event_pairs = self._impl.poll(poll_timeout)
        except Exception as e:
            # Depending on python version and IOLoop implementation,
            # different exception types may be thrown and there are
            # two ways EINTR might be signaled:
            # * e.errno == errno.EINTR
            # * e.args is like (errno.EINTR, 'Interrupted system call')
            if errno_from_exception(e) == errno.EINTR:
                continue
            else:
                raise
    
        if self._blocking_signal_threshold is not None:
            signal.setitimer(signal.ITIMER_REAL,
                             self._blocking_signal_threshold, 0)
    
        # Pop one fd at a time from the set of pending fds and run
        # its handler. Since that handler may perform actions on
        # other file descriptors, there may be reentrant calls to
        # this IOLoop that update self._events
        self._events.update(event_pairs)
        # 循环处理
        while self._events:
            fd, events = self._events.popitem()
            try:
                fd_obj, handler_func = self._handlers[fd]
                handler_func(fd_obj, events)
            except (OSError, IOError) as e:
                if errno_from_exception(e) == errno.EPIPE:
                    # Happens when the client closes the connection
                    pass
                else:
                    self.handle_callback_exception(self._handlers.get(fd))
            except Exception:
                self.handle_callback_exception(self._handlers.get(fd))
        fd_obj = handler_func = None

    作为客户端,实际上并不会用到IO多路复用,在tornado中是通过注册回调函数,ioloop每次都会在开始轮询callbacks数组并处理这些回调函数,其中的run_sync函数其实就是拿到用户定义的函数,利用内部的run函数注册回调函数,到时候直接执行。所以如果用户定义的函数是个协程,就必须使用gen.coroutine来激发协程,这也是gen.coroutine本质的作用。

    上面的代码里已经展示了运行callback的过程,如下:

    for callback in callbacks:
         self._run_callback(callback)

    总结:作为服务端,event loop的核心在于IO多路复用技术;作为客户端,event loop的核心在于利用Future对象延迟执行,并使用send函数激发协程,并不会使用到IO多路复用技术,但是对于IO还是做了优化的,可以看tornado TCPClient类的实现,socket设置为非阻塞,但是aiohttp对客户端的IO还是利用了IO多路复用技术,使得性能更好。所以不管是作为客户端还是服务端,event loop本质上都不是异步的,所以一定会有阻塞问题存在,在我知道的使用IO多路复用技术的这些框架中,大部分都是再利用线程池处理耗时的操作,这样会极大的提高并发量,神不知鬼不觉得达到了异步的效果。




    展开全文
  • Event monitor based on online news corpus including event storyline and analysis,基于给定事件关键词,采集事件资讯,对事件进行挖掘和分析。
  • python 事件 响应 钩子 event hooks

    千次阅读 2017-04-06 08:17:20
    # -*- coding: utf-8 -*- import requestsdef get_key_info(response, *args, **kwargs): """callback function""" print response.headers['Content-Type']def main(): """ 主程序 """ requests
    # -*- coding: utf-8 -*-
    import requests
    
    def get_key_info(response, *args, **kwargs):
        """callback function"""
        print response.headers['Content-Type']
    
    def main():
        """
        主程序
    
        """
        requests.get('http://www.baidu.com', hooks=dict(response=get_key_info))
    
    
    main()
    展开全文
  • 队列模拟器 在 Python 中对 M/M/s 排队系统进行简单的离散事件模拟,包括使用 pygame 的可视化。 这段代码被用作 Lehigh 大学 Python 算法课程实验室的示例。 课程网站在这里:
  • 本文实例讲述了Python tkinter事件高级用法。分享给大家供大家参考,具体如下: 先来看看运行效果: 完整实例代码: # -*- coding:utf-8-*- #! python3 from tkinter import * import threading, time trace = 0 ...
  • python事件处理

    千次阅读 2018-07-14 15:08:49
    from tkinter import *window = Tk()label = Label(window, text = "...)label.pack() #pack()使用一个包管理器将label放在容器中button.pack()window.mainloop() #创建一个事件循环,循环处理...
  • twisted:使用事件驱动机制来提升python性能 gevent:使用greenlet在用户态完成栈和上下文切换来减少切换带来的性能损耗 tornado:使用生成器来保存协程上下文及状态,使用原生的python语法实现了协程 asyncio:异步...
  • Fair Distributor 一个用于公平分配任务的python模块
  • python wait方法 Python Event.wait()方法 (Python Event.wait() Method) wait() is an inbuilt method of the Event class of the threading module in Python. wait()是Python中线程模块的Event类的内置方法。 ...
  • python event 事件类 events.py 类

    千次阅读 2020-04-10 08:09:34
    python event 事件类 events.py 类 Locust源码分析之events.py模块(5) https://blog.csdn.net/biheyu828/article/details/84983780 eventpy —— Python 事件派发和回调代码库 ...eventpy —— Python 事件...
  • python】详解事件驱动event实现

    万次阅读 多人点赞 2018-11-13 17:36:15
    脚本型:脚本型的程序包括最早的批处理文件以及使用Python做交易策略回测等等,这类程序的特点是在用户启动后会按照编程时设计好的步骤一步步运行,所有步骤运行完后自动退出。 连续运行型:连续运行型的程序包含了...
  • Python事件类| is_set()方法与示例

    千次阅读 2020-07-16 06:26:56
    Python Event.is_set()方法 (Python Event.is_set() Method) is_set() is an inbuilt method of the Event class of the threading module in Python. is_set()是Python中线程模块的Event类的内置方法。 An event ...
  • P是一种异步事件驱动的编程语言
  • 如果要开发一个比较大的程序,那么应该先把代码封装起来,在面向对象编程中,就是封装成类 先看代码: import tkinter as tk class App: def __init__(self, root): root.title(打招呼测试) ...
  • python中的事件

    千次阅读 2018-10-07 10:52:44
    一、事件模式 上面是控件或者窗体要绑定的事件模式,比如:键盘事件的模式&lt;Key&gt; #键盘事件,注意:在除了窗体外的控件上使用键盘事件要给控件添加焦点focus_set() def keyListen(event): print(&...
  • 本文实例为大家分享了python-opencv鼠标事件画框圈定目标的具体代码,供大家参考,具体内容如下 在视频/相机中,用鼠标画矩形框,圈定目标,从而获得鼠标的起始坐标点a、终止坐标点b # -*- coding: utf-8 -*- """ ...
  • 前言 ...PS:如有需要Python学习资料的小伙伴可以加点击下方链接自行获取 http://note.youdao.com/noteshare?id=3054cce4add8a909e784ad934f956cef 项目介绍 如何用图谱和结构化的方式,即以简洁...
  • 主要为大家详细介绍了python hook监听事件的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 206,778
精华内容 82,711
关键字:

python事件

python 订阅