精华内容
下载资源
问答
  • 主要介绍了python实现模拟按键自动翻页看u17漫画,十分简单实用,需要的朋友可以参考下
  • python实现模拟按键自动翻页

    千次阅读 2019-03-22 14:33:43
    python 适用于windows平台 使用 win32gui,win32api,...模拟按键翻页 Usage:python simu_read.py 10 1.5 10表示翻10页,1.5表示在一页中按pgdn的时间间隔为1.5s 一页pgdn 3 次,之后按→翻到下一页 把浏览器打开到u...

    python

    适用于windows平台
    使用 win32gui,win32api,win32con 包

    simu_read.py

    代码如下:

    #-*- coding=utf-8 -*-
    '''
    模拟按键翻页
    Usage:python simu_read.py 10 1.5
    10表示翻10页,1.5表示在一页中按pgdn的时间间隔为1.5s
    一页pgdn 3 次,之后按→翻到下一页
    把浏览器打开到u17要看的漫画中,之后启动该程序,再切回u17
    便可以自动翻页看漫画了。
    仅供娱乐,了解python模拟按键
    '''
    import win32gui,win32api,win32con
    from ctypes import *
    import time
    import threading
    import sys
    ''' # mouse click is not used here ,-> can replace it
    def get_cursor_pos():
    x,y = win32gui.GetCursorPos()
    return (x,y)
    def mouse_move(x,y):
    windll.user32.SetCursorPos(x, y)
    def mouse_click(x=None,y=None):
    print 'mouse_click'
    if not x is None and not y is None:
    mouse_move(x,y)
    time.sleep(0.05)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
    time.sleep(0.05)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)
    def test_pos():
    for i in range(0,10):
    time.sleep(0.5)
    print get_cursor_pos()
    '''
    def key_up(key_num):
    win32api.keybd_event(key_num,0,0,0) 
    win32api.keybd_event(key_num,0,win32con.KEYEVENTF_KEYUP,0)
    def init_dict():
    dict1 = {"PageDown":34,'RightArrow':39}
    return dict1
    if __name__ == '__main__':
    if len(sys.argv) != 3:
    print 'Usage:python simu_read.py <pagenum> <interval>'
    sys.exit(-1)
    try:
    pagenum = int(sys.argv[1])
    interval = float(sys.argv[2])
    except ValueError:
    print 'Usage:python simu_read.py <pagenum> <interval>'
    print '<pagenum> should be the type of int'
    print '<interval> should be the type of float'
    sys.exit(-1)
    if pagenum < 0 or pagenum > 10000:
    print 'pagenum should be in the range [1,10000]'
    sys.exit(-1)
    if interval < 0.1 or interval > 60:
    print 'interval should be in the range [0.1,60]'
    sys.exit(-1)
    key_dict = init_dict()
    stsec = 2
    print 'start in '+str(stsec)+' seconds...'
    time.sleep(stsec)
    for i in range(0,pagenum):
    for j in range(0,3):#generally,the height of one page is not more than 3 screensize
    print 'PageDown'
    key_up(key_dict['PageDown'])
    time.sleep(interval)
    key_up(key_dict['RightArrow'])
    print 'Next page'
    time.sleep(interval+0.2)#delay
    

    python实现模拟按键自动翻页就是这样的了。
    http://blog.sina.com.cn/s/blog_1a362b4290102ymfm.html

    展开全文
  • [620]使用Python实现一个按键精灵

    万次阅读 多人点赞 2019-06-11 23:32:20
    使用Python编写一个和脚本精灵一样的程序非常简单,并且代码量足够少,好处是可以不再依赖按键精灵,像我这种有轻微洁癖的程序猿就喜欢自己动手实现,依赖Python的为所欲为的特性,可以任意编码让自己的按键精灵更加...

    按键精灵想必很多人都玩过,使用录制功能将鼠标和键盘的操作录制下来,录制好后就可以通过回放自动执行之前录制的操作,可以设置重复执行的次数,这样就可以将一些重复的劳动交给脚本自动化去完成。使用Python编写一个和脚本精灵一样的程序非常简单,并且代码量足够少,好处是可以不再依赖按键精灵,像我这种有轻微洁癖的程序猿就喜欢自己动手实现,依赖Python的为所欲为的特性,可以任意编码让自己的按键精灵更加强大。

    按键精灵的实现可以拆解分为录制和回放两个步骤,对应到Python程序的实现也可以分为两步:
    1.监听鼠标键盘的事件和坐标,写入到文件中记录起来。
    2.读取监听时写入的文件,执行文件中的坐标和事件操作。

    要实现这两个功能,得先从基础开始。我把任务拆解成两大部分,鼠标和键盘属于不同的两个输入设备,所以分开实现“鼠标精灵”和“键盘精灵”两个程序,最后融合这两个模块实现一个相对完整的按键精灵。

    Python操作键盘鼠标的库推荐pynput这个库、地址:
    https://pypi.org/project/pynput/

    鼠标事件监听

    from pynput import mouse
    
    
    # 鼠标移动事件
    def on_move(x, y):
        print('[Move]', (x, y))
    
    
    # 鼠标点击事件
    def on_click(x, y, button, pressed):
        print('[Click]', (x, y, button.name, pressed))
    
    
    # 鼠标滚动事件
    def on_scroll(x, y, x_axis, y_axis):
        print('[Scroll]', (x, y, x_axis, y_axis))
    
    
    # 监听事件绑定
    with mouse.Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as listener:
        listener.join()
    

    onMove(x,y)函数接收鼠标当前的x轴和y轴坐标,启动程序并移动鼠标时,就会调用该方法。
    on_click(x, y, button, pressed)函数接收鼠标的点击事件,x和y为当前点击事件的鼠标坐标,button参数对象的name属性值为left或者right,通过该属性值可以判断是鼠标的左键还是右键产生的点击事件,pressed参数值为True时表示当前鼠标左或右键按压,False时表示鼠标左或右键抬起事件。
    on_scroll(x, y, x_axis, y_axis)接收四个参数,前两个参数依旧是当前事件的鼠标坐标轴,x_axis的值>0表示向上,<0表示向下,同样的y_axis的负值和正值代表左滑和右滑状态。

    鼠标事件执行

    from pynput.mouse import Button, Controller
    import time
    
    # 获取鼠标对象
    mouse = Controller()
    
    # 输出鼠标当前的坐标
    print(mouse.position)
    
    # 将新的坐标赋值给鼠标对象
    mouse.position = (100, 500)
    
    for index in range(0, 30):
        # 鼠标移动到指定坐标轴
        mouse.move(index, -index)
        print(mouse.position)
        time.sleep(0.01)
    
    for index in range(0, 30):
        # 鼠标移动到指定坐标轴
        mouse.move(-index, index)
        print(mouse.position)
        time.sleep(0.01)
    
    # 鼠标右键按下
    mouse.press(Button.right)
    
    time.sleep(0.01)
    
    # 鼠标右键抬起
    mouse.release(Button.right)
    
    # 鼠标左键点击
    mouse.click(Button.left, 1)
    
    # 鼠标滚轮滚动距离500
    mouse.scroll(0, 500)
    

    和鼠标事件监听一样,对应的我们可以操作鼠标的各种事件:移动、左/右按压、左/右抬起、左/右点击、上下左右滚动
    上面代码中的mouse.move(x,y)函数,表示从当前鼠标位置进行位移的距离,x和y的值是以当前位置为0点开始算的。
    而且不能简单的用坐标轴去相减得到位移距离,所以后续的程序我会使用mouse.position = (x, y)这个函数来操作鼠标的移动,
    这个函数可以将鼠标设置到指定位置,只要我们记录之前的鼠标移动轨迹,就可以通过读取之前的记录文件按顺序重新对鼠标进行赋值操作。达到回放的效果。

    带录制回放功能的鼠标精灵

    结合鼠标事件的监听和执行,并且将事件记录到文件中,再加上Python自带的GUI,就可以写出一个简单的鼠标精灵了。
    实现思路:

    1. 定义一个json格式的对象来统一不同鼠标事件的内容格式
    {
        "name":"mouse",
        "event":"click",
        "target":"left",
        "action":true,
        "location":{
            "x":"0",
            "y":"0"
        }
    }
    

    鼠标事件的name值为mouse,考虑到后续还有可能会有其他设备的事件,比如键盘事件。
    鼠标的事件为点击事件,将event赋值为click
    target表示目标,点击了鼠标左键,所以目标值为left
    action表示动作,鼠标点击分为按压和抬起,true表示抬起。
    location的值包含一个json对象,里面为当前事件鼠标的x和y坐标。
    鼠标的移动和滑动事件以此类推,用同样的模板格式进行记录。

    1. 将记录的数据写入到文件中
    2. 执行回放时通过逐行读取文件,解析文件中的json数据通过nameeventlocation等值进行事件执行。

    之所以选择json时因为解析起来比较方便。当然你也可以使用数据库,比如SQLite等,或者自己定义一套自己的格式。
    json的存储方式有太多的冗余字符了,空间占用目前不是考虑的首要因素,这里先用最快的方式实现它。

    GUI用了Python自带的tkinter库,为了防止UI阻塞,所以使用了多线程,同样是Python自带库threading
    整个实现其实只用了一个三方库 pynput

    鼠标事件的监听录制和执行回放的完整代码如下:

    import json
    import threading
    import time
    import tkinter
    
    from pynput import mouse
    from pynput.mouse import Button, Controller
    
    
    # 鼠标动作模板
    def mouse_action_template():
        return {
            "name": "mouse",
            "event": "default",
            "target": "default",
            "action": "default",
            "location": {
                "x": "0",
                "y": "0"
            }
        }
    
    
    # 鼠标动作监听
    class MouseActionListener(threading.Thread):
    
        def __init__(self, file_name):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'w', encoding='utf-8') as file:
                # 鼠标移动事件
                def on_move(x, y):
                    template = mouse_action_template()
                    template['event'] = 'move'
                    template['location']['x'] = x
                    template['location']['y'] = y
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                # 鼠标点击事件
                def on_click(x, y, button, pressed):
                    template = mouse_action_template()
                    template['event'] = 'click'
                    template['target'] = button.name
                    template['action'] = pressed
                    template['location']['x'] = x
                    template['location']['y'] = y
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                # 鼠标滚动事件
                def on_scroll(x, y, x_axis, y_axis):
                    template = mouse_action_template()
                    template['event'] = 'scroll'
                    template['location']['x'] = x_axis
                    template['location']['y'] = y_axis
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                with mouse.Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as listener:
                    listener.join()
    
    
    # 鼠标动作执行
    class MouseActionExecute(threading.Thread):
    
        def __init__(self, file_name):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'r', encoding='utf-8') as file:
                mouse_exec = Controller()
                line = file.readline()
                time.sleep(0.01)
                while line:
                    obj = json.loads(line)
                    if obj['name'] == 'mouse':
                        if obj['event'] == 'move':
                            mouse_exec.position = (obj['location']['x'], obj['location']['y'])
                            time.sleep(0.01)
                        elif obj['event'] == 'click':
                            if obj['action']:
                                if obj['target'] == 'left':
                                    mouse_exec.press(Button.left)
                                else:
                                    mouse_exec.press(Button.right)
                            else:
                                if obj['target'] == 'left':
                                    mouse_exec.release(Button.left)
                                else:
                                    mouse_exec.release(Button.right)
                            time.sleep(0.01)
                        elif obj['event'] == 'scroll':
                            mouse_exec.scroll(obj['location']['x'], obj['location']['y'])
                            time.sleep(0.01)
                    line = file.readline()
    
    
    def button_onClick(action):
    
        m1 = MouseActionListener(file_name='mouse.action')
        m2 = MouseActionExecute(file_name='mouse.action')
    
        if action == 'listener':
            if startListenerBtn['text'] == '录制':
                m1.start()
                startListenerBtn['text'] = '录制中...关闭程序停止录制'
                startListenerBtn['state'] = 'disabled'
    
        elif action == 'execute':
            if startExecuteBtn['text'] == '回放':
                m2.start()
                startExecuteBtn['text'] = '回放中...关闭程序停止回放'
                startExecuteBtn['state'] = 'disabled'
    
    
    if __name__ == '__main__':
    
        root = tkinter.Tk()
        root.title('鼠标精灵-蓝士钦')
        root.geometry('200x200+400+100')
    
        startListenerBtn = tkinter.Button(root, text="录制", command=lambda: button_onClick('listener'))
        startListenerBtn.place(x=10, y=10, width=180, height=80)
    
        startExecuteBtn = tkinter.Button(root, text="回放", command=lambda: button_onClick('execute'))
        startExecuteBtn.place(x=10, y=110, width=180, height=80)
        root.mainloop()
    

    按键精灵的鼠标部分到这里就基本完成了。
    运行程序,点击录制,然后就可以用你的鼠标在屏幕上一顿操作。然后关闭本程序。
    接着重新打开程序,点击回放,就会发现鼠标可以按照之前录制的动作进行自动工作了。
    记住千万不要在录制时,还没关闭程序的时候就点击回放,这样会陷入无限循环里面,会导致不停的录制不停的回放。
    还有键盘的程序后续补上,程序待完善中,未完待续。

    键盘事件监听

    from pynput import keyboard
    
    
    # 按键按下监听
    def on_press(key):
        try:
            print('press key {0}, vk: {1}'.format(key.char, key.vk))
        except AttributeError:
            print('special press key {0}, vk: {1}'.format(key, key.value.vk))
    
    
    # 按键释放监听
    def on_release(key):
    
        if key == keyboard.Key.esc:
            # 停止监听
            return False
    
        try:
            print('release key {0}, vk: {1}'.format(key.char, key.vk))
        except AttributeError:
            print('special release key {0}, vk: {1}'.format(key, key.value.vk))
    
    
    # 键盘监听
    with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
        listener.join()
    

    键盘监听相对于鼠标监听来说,回调的函数只有两个on_press按键按下 和on_release按键释放。
    由于pynput这个库对键盘的不同按键事件封装进行了区分,比如普通的数字和字母键按下会进入on_press方法,通过传入的key.char属性值可以得到按键对应在键盘上的字符,但如果是Shift等其他特殊键,就没有char属性,会产生异常。
    只要捕获异常后直接通过key就可以取到特殊键对应的字符。我觉得这是pynput做得有点不够优雅的地方。
    普通的键有key.vk属性值,代表键盘上字符对应的编码值,特殊键的编码值要通过key.value.vk来取。

    键盘事件执行

    from pynput.keyboard import Key, Controller, KeyCode
    
    # 键盘控制对象
    keyboard = Controller()
    
    # 按下 a 键
    keyboard.press('a')
    # 释放 a 键
    keyboard.release('a')
    
    # 按下 Shift 键
    keyboard.press(Key.shift)
    keyboard.press('b')
    keyboard.release('b')
    keyboard.press('c')
    keyboard.release('c')
    # 释放 Shift 键
    keyboard.release(Key.esc)
    
    # 按下 Shift 键,然后依次按下其他按键,完成后Shift键自动释放
    with keyboard.pressed(Key.shift):
        keyboard.press('d')
        keyboard.release('d')
        keyboard.press('e')
        keyboard.release('e')
    
    # 依次按下 python (包括前面的空格)
    keyboard.type(' python')
    
    # 按下 vk值为56的键 shift 键
    keyboard.touch(KeyCode.from_vk(56), True)
    keyboard.touch('a', True)
    keyboard.touch('a', False)
    # 释放 shift 键
    keyboard.touch(Key.shift, False)
    

    和监听方法对应,执行键盘的按键方法有press(key)按压 release(key)释放。
    除此之外还有touch(key,is_press)函数,key表示要操作的键,is_press 为True时表示按压,为False时表示释放。
    无论是哪种按压事件,Key都可以通过其他方式构造,比如知道Shift的vk值为56,那么就可以通过KeyCode.from_vk(56)来构造一个Shift的Key。
    通过VK编码构造Key的方式很有用,因为当你要按出一个@符号时,需要同时按住Shift2。通过on_press(key)监听得到的值是一个@符号,如果录制程序录制了一个@符号将无法通过keyboard.press('@')这种方式直接执行。
    所以接下来的键盘录制回放程序我将通过定义一个键盘动作模板,然后通过VK值准确的记录每个键以及每个组合键的编码。然后通过keyboard.press(KeyCode.from_vk(vk))进行回放。

    带录制回放功能的键盘精灵

    import json
    import threading
    import time
    import tkinter
    
    from pynput import keyboard
    from pynput.keyboard import Controller, KeyCode
    
    
    # 键盘动作模板
    def keyboard_action_template():
        return {
            "name": "keyboard",
            "event": "default",
            "vk": "default"
        }
    
    
    # 键盘动作监听
    class KeyboardActionListener(threading.Thread):
    
        def __init__(self, file_name):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'w', encoding='utf-8') as file:
                # 键盘按下监听
                def on_press(key):
                    template = keyboard_action_template()
                    template['event'] = 'press'
                    try:
                        template['vk'] = key.vk
                    except AttributeError:
                        template['vk'] = key.value.vk
                    finally:
                        file.writelines(json.dumps(template) + "\n")
                        file.flush()
    
                # 键盘抬起监听
                def on_release(key):
                    if key == keyboard.Key.esc:
                        # 停止监听
                        startListenerBtn['text'] = '录制'
                        startListenerBtn['state'] = 'normal'
                        return False
                    template = keyboard_action_template()
                    template['event'] = 'release'
                    try:
                        template['vk'] = key.vk
                    except AttributeError:
                        template['vk'] = key.value.vk
                    finally:
                        file.writelines(json.dumps(template) + "\n")
                        file.flush()
    
                # 键盘监听
                with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
                    listener.join()
    
    
    # 键盘动作执行
    class KeyboardActionExecute(threading.Thread):
    
        def __init__(self, file_name):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'r', encoding='utf-8') as file:
                keyboard_exec = Controller()
                line = file.readline()
                time.sleep(3)
                while line:
                    obj = json.loads(line)
                    if obj['name'] == 'keyboard':
                        if obj['event'] == 'press':
                            keyboard_exec.press(KeyCode.from_vk(obj['vk']))
                            time.sleep(0.01)
    
                        elif obj['event'] == 'release':
                            keyboard_exec.release(KeyCode.from_vk(obj['vk']))
                            time.sleep(0.01)
                    line = file.readline()
                startExecuteBtn['text'] = '回放'
                startExecuteBtn['state'] = 'normal'
    
    
    def button_onClick(action):
        m1 = KeyboardActionListener(file_name='keyboard.action')
        m2 = KeyboardActionExecute(file_name='keyboard.action')
    
        if action == 'listener':
            if startListenerBtn['text'] == '录制':
                m1.start()
                startListenerBtn['text'] = '录制中...esc停止录制'
                startListenerBtn['state'] = 'disabled'
    
        elif action == 'execute':
        	startListenerBtn.place(x=10, y=10, width=180, height=80)
        	startExecuteBtn = tkinter.Button(root, text="回放", command=lambda: button_onClick('execute'))
        	startExecuteBtn.place(x=10, y=110, width=180, height=80)
        	root.mainloop()
    

    键盘精灵的录制和回放程序到这里以及算是一个基础版本了,可以正常使用。并且新增了esc键监听,当用户点击esc时将会结束录制。
    鼠标精灵键盘精灵都可以单独的运行使用。
    大多数场景下这两者的功能都会使用到,所以接下来我要实现一个完成的按键精灵,同时包含鼠标和键盘的录制回放功能。
    在之前的代码基础上进一步封装。

    考虑的基本要素如下:

    1. 记录鼠标和记录键盘的事件采用不同的json模板进行定义,采用响应式对用户的操作进行监听,用户静止不动则不会写入文件。
    2. 同时监听鼠标和键盘,为了避免多线程写同一个文件的锁操作,我将鼠标和键盘的录制记录分为两个不同的文件。
    3. 录制和回放的操作通常都需要有一个等待时间的设置,所以代码里加上了GUI的设置部分,GUI没有设计所以后续这块代码要优化。
    4. 考虑录制和回放倒计时需要UI提示用户并且定时触发线程执行,所以封装了一个UI更新线程的类。

    按键精灵0.1版本完整代码如下:

    键鼠录制的按键精灵0.1版本

    import json
    import threading
    import time
    import tkinter
    
    from pynput import keyboard, mouse
    from pynput.keyboard import Controller as KeyBoardController, KeyCode
    from pynput.mouse import Button, Controller as MouseController
    
    
    # 键盘动作模板
    def keyboard_action_template():
        return {
            "name": "keyboard",
            "event": "default",
            "vk": "default"
        }
    
    
    # 鼠标动作模板
    def mouse_action_template():
        return {
            "name": "mouse",
            "event": "default",
            "target": "default",
            "action": "default",
            "location": {
                "x": "0",
                "y": "0"
            }
        }
    
    
    # 倒计时监听,更新UI触发自定义线程对象
    class UIUpdateCutDownExecute(threading.Thread):
        def __init__(self, cut_down_time, custom_thread_list):
            super().__init__()
            self.cut_down_time = cut_down_time
            self.custom_thread_list = custom_thread_list
    
        def run(self):
            while self.cut_down_time > 0:
                for custom_thread in self.custom_thread_list:
                    if custom_thread['obj_ui'] is not None:
                        custom_thread['obj_ui']['text'] = str(self.cut_down_time)
                        custom_thread['obj_ui']['state'] = 'disabled'
                        self.cut_down_time = self.cut_down_time - 1
                time.sleep(1)
            else:
                for custom_thread in self.custom_thread_list:
                    if custom_thread['obj_ui'] is not None:
                        custom_thread['obj_ui']['text'] = custom_thread['final_text']
                        custom_thread['obj_ui']['state'] = 'disabled'
                    if custom_thread['obj_thread'] is not None:
                        custom_thread['obj_thread'].start()
                        time.sleep(1)
    
    
    # 键盘动作监听
    class KeyboardActionListener(threading.Thread):
    
        def __init__(self, file_name='keyboard.action'):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'w', encoding='utf-8') as file:
                # 键盘按下监听
                def on_press(key):
                    template = keyboard_action_template()
                    template['event'] = 'press'
                    try:
                        template['vk'] = key.vk
                    except AttributeError:
                        template['vk'] = key.value.vk
                    finally:
                        file.writelines(json.dumps(template) + "\n")
                        file.flush()
    
                # 键盘抬起监听
                def on_release(key):
                    if key == keyboard.Key.esc:
                        # 停止监听
                        startListenerBtn['text'] = '开始录制'
                        startListenerBtn['state'] = 'normal'
                        keyboardListener.stop()
                        return False
                    template = keyboard_action_template()
                    template['event'] = 'release'
                    try:
                        template['vk'] = key.vk
                    except AttributeError:
                        template['vk'] = key.value.vk
                    finally:
                        file.writelines(json.dumps(template) + "\n")
                        file.flush()
    
                # 键盘监听
                with keyboard.Listener(on_press=on_press, on_release=on_release) as keyboardListener:
                    keyboardListener.join()
    
    
    # 键盘动作执行
    class KeyboardActionExecute(threading.Thread):
    
        def __init__(self, file_name='keyboard.action', execute_count=0):
            super().__init__()
            self.file_name = file_name
            self.execute_count = execute_count
    
        def run(self):
            while self.execute_count > 0:
                with open(self.file_name, 'r', encoding='utf-8') as file:
                    keyboard_exec = KeyBoardController()
                    line = file.readline()
                    while line:
                        obj = json.loads(line)
                        if obj['name'] == 'keyboard':
                            if obj['event'] == 'press':
                                keyboard_exec.press(KeyCode.from_vk(obj['vk']))
                                time.sleep(0.01)
    
                            elif obj['event'] == 'release':
                                keyboard_exec.release(KeyCode.from_vk(obj['vk']))
                                time.sleep(0.01)
                        line = file.readline()
                    startExecuteBtn['text'] = '开始回放'
                    startExecuteBtn['state'] = 'normal'
                self.execute_count = self.execute_count - 1
    
    
    # 鼠标动作监听
    class MouseActionListener(threading.Thread):
    
        def __init__(self, file_name='mouse.action'):
            super().__init__()
            self.file_name = file_name
    
        def run(self):
            with open(self.file_name, 'w', encoding='utf-8') as file:
                # 鼠标移动事件
                def on_move(x, y):
                    template = mouse_action_template()
                    template['event'] = 'move'
                    template['location']['x'] = x
                    template['location']['y'] = y
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                # 鼠标点击事件
                def on_click(x, y, button, pressed):
                    template = mouse_action_template()
                    template['event'] = 'click'
                    template['target'] = button.name
                    template['action'] = pressed
                    template['location']['x'] = x
                    template['location']['y'] = y
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                # 鼠标滚动事件
                def on_scroll(x, y, x_axis, y_axis):
                    template = mouse_action_template()
                    template['event'] = 'scroll'
                    template['location']['x'] = x_axis
                    template['location']['y'] = y_axis
                    file.writelines(json.dumps(template) + "\n")
                    file.flush()
    
                with mouse.Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as mouseListener:
                    mouseListener.join()
    
    
    # 鼠标动作执行
    class MouseActionExecute(threading.Thread):
    
        def __init__(self, file_name='mouse.action', execute_count=0):
            super().__init__()
            self.file_name = file_name
            self.execute_count = execute_count
    
        def run(self):
            while self.execute_count > 0:
                with open(self.file_name, 'r', encoding='utf-8') as file:
                    mouse_exec = MouseController()
                    line = file.readline()
                    while line:
                        obj = json.loads(line)
                        if obj['name'] == 'mouse':
                            if obj['event'] == 'move':
                                mouse_exec.position = (obj['location']['x'], obj['location']['y'])
                                time.sleep(0.01)
                            elif obj['event'] == 'click':
                                if obj['action']:
                                    if obj['target'] == 'left':
                                        mouse_exec.press(Button.left)
                                    else:
                                        mouse_exec.press(Button.right)
                                else:
                                    if obj['target'] == 'left':
                                        mouse_exec.release(Button.left)
                                    else:
                                        mouse_exec.release(Button.right)
                                time.sleep(0.01)
                            elif obj['event'] == 'scroll':
                                mouse_exec.scroll(obj['location']['x'], obj['location']['y'])
                                time.sleep(0.01)
                        line = file.readline()
    
    
    def command_adapter(action):
        if action == 'listener':
            if startListenerBtn['text'] == '开始录制':
                custom_thread_list = [
                    {
                        'obj_thread': KeyboardActionListener(),
                        'obj_ui': startListenerBtn,
                        'final_text': '录制中...esc停止录制'
                    },
                    {
                        'obj_thread': MouseActionListener(),
                        'obj_ui': None,
                        'final_text': None
                    }
                ]
                UIUpdateCutDownExecute(startTime.get(), custom_thread_list).start()
    
        elif action == 'execute':
            if startExecuteBtn['text'] == '开始回放':
                custom_thread_list = [
                    {
                        'obj_thread': KeyboardActionExecute(execute_count=playCount.get()),
                        'obj_ui': startExecuteBtn,
                        'final_text': '回放中...关闭程序停止回放'
                    },
                    {
                        'obj_thread': MouseActionExecute(execute_count=playCount.get()),
                        'obj_ui': None,
                        'final_text': None
                    }
                ]
                UIUpdateCutDownExecute(endTime.get(), custom_thread_list).start()
    
    
    def isNumber(content):
        if content.isdigit() or content == "":
            return True
        else:
            return False
    
    
    if __name__ == '__main__':
        root = tkinter.Tk()
        root.title('按键精灵-蓝士钦')
        root.geometry('200x200+400+100')
    
        listenerStartLabel = tkinter.Label(root, text='录制倒计时')
        listenerStartLabel.place(x=10, y=10, width=80, height=20)
        startTime = tkinter.IntVar()
        listenerStartEdit = tkinter.Entry(root, textvariable=startTime)
        listenerStartEdit.place(x=100, y=10, width=60, height=20)
        startTime.set(3)
    
        listenerTipLabel = tkinter.Label(root, text='秒')
        listenerTipLabel.place(x=160, y=10, width=20, height=20)
    
        startListenerBtn = tkinter.Button(root, text="开始录制", command=lambda: command_adapter('listener'))
        startListenerBtn.place(x=10, y=45, width=180, height=30)
    
        executeEndLabel = tkinter.Label(root, text='回放倒计时')
        executeEndLabel.place(x=10, y=85, width=80, height=20)
        endTime = tkinter.IntVar()
        executeEndEdit = tkinter.Entry(root, textvariable=endTime)
        executeEndEdit.place(x=100, y=85, width=60, height=20)
        endTime.set(6)
    
        executeTipLabel = tkinter.Label(root, text='秒')
        executeTipLabel.place(x=160, y=85, width=20, height=20)
    
        playCountLabel = tkinter.Label(root, text='回放次数')
        playCountLabel.place(x=10, y=115, width=80, height=20)
        playCount = tkinter.IntVar()
        playCountEdit = tkinter.Entry(root, textvariable=playCount)
        playCountEdit.place(x=100, y=115, width=60, height=20)
        playCount.set(1)
    
        playCountTipLabel = tkinter.Label(root, text='次')
        playCountTipLabel.place(x=160, y=115, width=20, height=20)
    
        startExecuteBtn = tkinter.Button(root, text="开始回放", command=lambda: command_adapter('execute'))
        startExecuteBtn.place(x=10, y=145, width=180, height=30)
        root.mainloop()
    

    脚本精灵0.1版本完成?

    image

    还需要考虑的点:

    1. 键盘事件没有记录用户每个动作之间的延迟时间,无法准确重放用户的输入节奏,后续考虑记录时间间隔点。
    2. 鼠标事件用户移动的越快,产生的点位变化也就越频繁,所以鼠标在回放时的速度与用户的操作基本一致。
    3. 鼠标没有停止回放的快捷键,要考虑如何停止回放鼠标事件。
    4. 输入法切换可能导致重放键盘按键时输入不准确,需要录制时是什么输入状态,重放时也要对应的键盘属性和状态
    5. …还有很多需要考虑的点(原本只是想简单的做个示例程序)

    程序只在MacOS平台上实验过,其他平台还未实验,一个相对完整的按键精灵在录制时应该获取更多的信息,这样在回放的时候才足够准确,后续考虑做一个更加精确的按键精灵,比如加入获取屏幕像素点,回放时通过采样比对,达到为所欲为功能。
    GitHub地址:
    https://github.com/lanshiqin/JerryMouse
    期待大家来一起完善它?

    来源:https://www.lanshiqin.com/2fb233e2/

    展开全文
  • 但是该方法需要写被操作对象的locator,不是很方便,现在找到了一种win32api库写键盘操作的一个方法(注意:此方法被操作界面必须在顶层),首先,需要安装win32api的python库,使用命令:pip install pywin32具体...

    原来在robotframework中使用press key方法进行键盘的操作,但是该方法需要写被操作对象的locator,不是很方便,现在找到了一种win32api库写键盘操作的一个方法(注意:此方法被操作界面必须在顶层),首先,需要安装win32api的python库,使用命令:

    pip install pywin32

    具体实现代码如下:

    import win32api

    import win32con

    class MyLibrary(object):

    def keybd_event(self,VK_CODE): #VK_CODE为键盘编码

    # @Keyboard

    # input

    VK_CODE = int(VK_CODE)

    print ":::VK_CODE:", VK_CODE

    win32api.keybd_event(VK_CODE, 0, 0, 0)

    win32api.keybd_event(VK_CODE, 0, win32con.KEYEVENTF_KEYUP, 0)

    print ":::press", str(VK_CODE), "successfully!"

    time.sleep(2)

    if __name__ == "__main__":

    keybd_event(40) #键盘按下方向向下键

    常见键盘编码:(来自百度)

    ESC键VK_ESCAPE (27)

    回车键:VK_RETURN (13)

    TAB键:VK_TAB (9)

    Caps Lock键:VK_CAPITAL (20)

    Shift键:VK_SHIFT (16)

    Ctrl键:VK_CONTROL (17)

    Alt键:VK_MENU (18)

    空格键:VK_SPACE (32)

    退格键:VK_BACK (8)

    左徽标键:VK_LWIN (91)

    右徽标键:VK_RWIN (92)

    鼠标右键快捷键:VK_APPS (93)

    Insert键:VK_INSERT (45)

    Home键:VK_HOME (36)

    Page Up:VK_PRIOR (33)

    PageDown:VK_NEXT (34)

    End键:VK_END (35)

    Delete键:VK_DELETE (46)

    方向键(←):VK_LEFT (37)

    方向键(↑):VK_UP (38)

    方向键(→):VK_RIGHT (39)

    方向键(↓):VK_DOWN (40)

    F1键:VK_F1 (112)

    F2键:VK_F2 (113)

    F3键:VK_F3 (114)

    F4键:VK_F4 (115)

    F5键:VK_F5 (116)

    F6键:VK_F6 (117)

    F7键:VK_F7 (118)

    F8键:VK_F8 (119)

    F9键:VK_F9 (120)

    F10键:VK_F10 (121)

    F11键:VK_F11 (122)

    F12键:VK_F12 (123)

    Num Lock键:VK_NUMLOCK (144)

    小键盘0:VK_NUMPAD0 (96)

    小键盘1:VK_NUMPAD1 (97)

    小键盘2:VK_NUMPAD2 (98)

    小键盘3:VK_NUMPAD3 (99)

    小键盘4:VK_NUMPAD4 (100)

    小键盘5:VK_NUMPAD5 (101)

    小键盘6:VK_NUMPAD6 (102)

    小键盘7:VK_NUMPAD7 (103)

    小键盘8:VK_NUMPAD8 (104)

    小键盘9:VK_NUMPAD9 (105)

    小键盘。:VK_DECIMAL (110)

    小键盘*:VK_MULTIPLY (106)

    小键盘+:VK_ADD (107)

    小键盘-:VK_SUBTRACT (109)

    小键盘/:VK_DIVIDE (111)

    Pause Break键:VK_PAUSE (19)

    Scroll Lock键:VK_SCROLL (145)

    以上这篇在自动化中用python实现键盘操作的方法详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • python 实现截图自动存入Excel表

    千次阅读 2019-12-31 21:02:49
    python 实现截图自动存入Excel表 首先我先在桌面新建一个test.xls文件 import keyboard #监听按键库 from PIL import ImageGrab #图像处理库 import time from aip import AipOcr #pip install baidu_aip\ import ...

    python 实现截图自动存入Excel表

    首先我先在桌面新建一个test.xls文件

    import keyboard #监听按键库
    from PIL import ImageGrab #图像处理库
    import time
    from aip import AipOcr #pip install baidu_aip\
    import xlwt
    
    biao = xlwt.Workbook()
    worksheet = biao.add_sheet('sheet1')
    
    # print("开始截图")
    
    # 1. 截取图片
    num=0
    
    while 1:
    
        keyboard.wait(hotkey='ctrl+alt+a')
        print("键盘按下了'ctrl+alt+a'")
        keyboard.wait('enter')
        print("键盘按下了'enter'")
    
        # 模拟延迟,来解决grabclipboard函数的缓存问题(grabclipboard函数操作太快,它就会读取上一次的内容)
        time.sleep(0.1)
    
        # 2. 保存图片到电脑上
        image = ImageGrab.grabclipboard()
        image.save('screen%s.png'%(num))
    
        # 3. 调用百度AI识别图片内容
        APP_ID = '你的APP_ID'
        API_KEY = '你的API_KEY'
        SECRET_KEY = '你的SECRET_KEY'
    
        client = AipOcr(APP_ID, API_KEY, SECRET_KEY)
    
        # 获取图片的二进制数据
        def get_file_content(filePath):
            with open(filePath, 'rb') as fp:
                return fp.read()
    
        image = get_file_content('screen%s.png'%(num))
    
        """ 调用通用文字识别(高精度版) """
        text = client.basicAccurate(image)
    
    
        textList = text['words_result']
    
    
        print(textList)
        num1 = 0
        for i in textList:
    
            worksheet.write(num, num1, i['words'])
            biao.save('C:\\Users\\mxy\\Desktop\\test.xls')
            num1 += 1
        num+=1
    
    
        print("结束截图")
    
    

    新年快乐!

    展开全文
  • python实现键盘自动输入

    万次阅读 2019-06-06 16:36:19
    Keybd_event()函数能触发一个按键事件,也就是说会产生一个WM_KEYDOWN或WM_KEYUP消息。 该函数原型如下: VOID keybd_event( BYTE bVk, // virtual-key code BYTE bScan, // hardware scan code...
  • Python图片处理模块PIL(pillow) pywin32的主要作用 1.捕获窗口; 2.模拟鼠标键盘动作; 3.自动获取某路径下文件列表; 4.PIL截屏功能 找色点击功能思路: 抓取当前屏幕快照,指定一个坐标和颜色,如果坐标的颜色符合...
  • 在开发过程中发现一个问题:代码中同时使用了getchar()和getch()两个函数,从自动测试角度看,getchar()好处理,它的来源是缓冲区,利用python的管道很容易搞定,而getch()就麻烦了,它是直接来源于键盘中断,管道在...
  • 最近尝试控制台小程序,以及快捷键组合的时候需要用到侦听键盘事件的操作,然后查阅了相关的材料,发现keyboard模块比较...如何自动按键 如何用python实现按方向键可上下移动 python实现按一个键执行一个函数的功能
  • Python图片处理模块PIL(pillow) pywin32的主要作用 1.捕获窗口;2.模拟鼠标键盘动作;3.自动获取某路径下文件列表;4.PIL截屏功能 找色点击功能思路: 抓取当前屏幕快照,指定一个坐标和颜色,如果坐标的颜色符合...
  • flash钢琴自动弹奏之Python实现

    千次阅读 2013-07-19 17:38:32
    linux系统下没有WSH可用,需要自己实现按键sendkey?python已有实现,virtkey拿来用即可。 不过需要注意的是,按键长度与延时是并行关系。 简单实现: #!/usr/bin/python import virtkey import time import ...
  • 10行Python代码实现Web自动化管控

    千次阅读 多人点赞 2020-08-09 15:50:28
    本博客将为各位分享Python Helium库,其是在 Selenium库基础上封装的更加高级的 Web 自动化工具,它能够通过网页端可见的标签、名称来和 Web 进行交互,据说比Selenium库简单50%,Helium库主要功能包括:模拟鼠标...
  • 输入文字,组合按键(ctrl + a),功能按键(向上箭头ARROW_UP等) 二、操作实例 1、输入文字:send_keys from selenium import webdriver from time import sleep driver = webdriver.Chrome() driver
  • Python键盘按键模拟

    千次阅读 2019-06-21 10:07:00
    有时候我们需要使用python执行一些脚本,可能需要让程序自动按键或自动点击鼠标,下面的代码实现了对键盘的模拟按键, 需要安装pypiwin32,当然也可以直接用ctypes来实现。 输入:pip install pypiwin32 安装...
  • 接着上篇介绍input里面的按键操作keyevent事件,发送手机上常用的一些按键操作 keyevent 1.keyevent事件有一张对应的表,可以直接发送对应的数字,也可以方式字符串,如下两个方法都能实现back键。打开cmd输入指令...
  • Mac系统下wow自动钓鱼python实现

    千次阅读 2020-02-29 10:45:42
    一. 缘起 因为最近疫情的原因,待在家里实在无聊就又玩起了wow怀旧服...最开始的时候,在b站上找了一个wow钓鱼的介绍视频,看了一下大概思路,但是没什么用,里面用的是按键精灵且系统为windows. https://www.bili...
  • 就是通过adb实现自动跳跃.在手机使用按键精灵的脚本其实原理也都大同小异,确定坐标-点击-延时这几步. ps.脚本只要不是恶意脚本,例如用于游戏中的刷材料经验,或是多次点击刷数据的行为,编写脚本,释放双手,还是挺滋润...
  • ··send_keys在对象上模拟按键输入 ··clear清除对象的内容,如果可以的话 WebElement另一些常用方法: ··text获取该元素的文本 ··submit提交表单 ··get_attribute获得属性值 =======================...
  • 本博客将为各位分享Python Helium库,其是在 Selenium库基础上封装的更加高级的 Web 自动化工具,它能够通过网页端可见的标签、名称来和 Web 进行交互,据说比Selenium库简单50%,Helium库主要功能包括:模拟鼠标...
  • 本文实例讲述了Python PyAutoGUI模块控制鼠标和键盘实现自动化任务。分享给大家供大家参考,具体如下: PyAutoGUI是用Python写的一个模块,使用它可以控制鼠标和键盘。 利用它可以实现自动化任务,再也不用担心有...
  • python入门(三) 实现QQ自动发送消息

    万次阅读 多人点赞 2018-10-28 18:52:44
    前面二章简单过了一下python的基本知识,最近刚好需要实现QQ自动发送消息的脚本,于是便拿python来练手。 业务逻辑 1、打开需要发送消息的窗口 2、锁定该窗口 3、将需要发送的内容放到QQ窗口 4、模拟按键发送...
  • Python的交互式命令行可...此处为大家举一个简单的启动脚本文件例子,它为python命令行添加了按键自动补全内容和历史命令功能。 [python@python ~]$ cat .pythonstartup import readline import rlcompleter import
  • <code class="language-python">#尝试通过python自动鼠键模块autopy实现Ctrl+A的全选效果 import autopy as at import time time.sleep(2) #尝试1 直接报错 TypeError at.key.toggle('A',True,[at....
  • python学习之 实现QQ自动发送消息

    千次阅读 2020-05-28 18:14:11
    4、模拟按键发送enter键发送消息(QQ发送消息有二种方式Enter/Ctrl+Enter,本次案例使用Enter) 环境 win10 + python3.7.1 从业务上看,程序需要对window的窗口进行操作,应此需要安装pywin32来访问win32API pywin32...
  • 接着上篇介绍input里面的按键操作keyevent事件,发送手机上常用的一些按键操作 keyevent 1.keyevent事件有一张对应的表,可以直接发送对应的数字,也可以方式字符串,如下两个方法都能实现back键。打开cmd输入指令...
  • python模拟按键与鼠标操作(一)

    千次阅读 2020-04-10 01:54:23
    有时候我们需要使用python执行一些脚本,可能需要让程序自动按键或自动点击鼠标,下面的代码实现了对键盘的模拟按键, 需要安装pypiwin32,当然也可以直接用ctypes来实现。 输入:pip install pypiwin32 安装pypiwin...

空空如也

空空如也

1 2 3 4 5 6
收藏数 113
精华内容 45
关键字:

python实现自动按键

python 订阅