• [python]python监听、操作键盘鼠标库pynput详细教程

    1.【pynput简介】pynput简介，官方是这样介绍自己的：

    pynput这个库，允许你控制、监听输入设备。例如监听鼠标、键盘的各种操作。

    1. This library allows you to control and monitor input devices.
    2.  
    3. It contains subpackages for each type of input device supported:
    4.  
    5. pynput.mouse
    6. Contains classes for controlling and monitoring a mouse or trackpad.
    7. pynput.keyboard
    8. Contains classes for controlling and monitoring the keyboard.

    附官方文档：https://pynput.readthedocs.io/en/latest/

    后面我们大概流程也将按照以下顺序介绍它的用法。

    1. 鼠标：“控制鼠标”“鼠标按键”“监听鼠标”，
    2. 键盘：“控制键盘”“键盘按键”“监听键盘”

    2.【pynput安装和导入】pynput安装，安装时，会自动安装所依赖的其他库。

    pip install pynput

    导入核心模块：

    from pynput import mouse, keyboard

    3.【鼠标位置】pynput.mouse包里面包含了控制鼠标和监听鼠标的类。可以这样导入：

    from pynput.mouse import Button, Controller

    鼠标的按键在pynput.mouse.Button中，有lift、right、middle还有unknown四种。

    每一个按键都有两个有意义的属性：name和value。name是该按键的名称，比如 Button.left.name == 'left'；
    value是记录上一次点击位置的元组。

    • 获取当前鼠标位置：
    1. from pynput.mouse import Button, Controller
    2.  
    3. # 鼠标控制器
    4. mouse = Controller()
    5.  
    6. # 获取当前鼠标位置
    7. print('当前鼠标位置： {}'.format(mouse.position))

    打印结果：

    当前鼠标位置： (303.5851135253906, 71.71687316894531)
    • 设置鼠标移动到某位置（绝对位置）：
    1. from pynput.mouse import Button, Controller
    2.  
    3. # 鼠标控制器 
    4. mouse = Controller()  
    5.  
    6. # 设置鼠标都某位置 
    7. mouse.position = (x, y)

    示例代码如下：

    1. import time
    2. from pynput.mouse import Button, Controller
    3.  
    4. # 鼠标控制器
    5. mouse = Controller()
    6.  
    7. # 设置鼠标都某位置
    8. mouse.position = (10, 20)
    9.  
    10. # 给点反应时间
    11. time.sleep(1)
    12.  
    13. print('当前鼠标位置： {}'.format(mouse.position))

    打印结果：

    当前鼠标位置： (10.0, 20.0)
    • 设置鼠标移动到某位置（相对当前位置移动）
    1. from pynput.mouse import Button, Controller
    2.  
    3. # 鼠标控制器 
    4. mouse = Controller()  
    5.  
    6. # 鼠标相对当前位置移动：
    7. mouse.move(250, 250)

    示例代码如下：

    1. import time
    2. from pynput.mouse import Button, Controller
    3.  
    4. # 鼠标控制器
    5. mouse = Controller()
    6.  
    7.  
    8. # 设置鼠标都某位置
    9. mouse.position = (10, 20)
    10.  
    11. # 留点反应时间再打印
    12. time.sleep(1)
    13. print('当前鼠标位置： {}'.format(mouse.position))
    14.  
    15.  
    16. # 鼠标相对当前位置移动：
    17. mouse.move(250, 250)
    18.  
    19. # 留点反应时间再打印
    20. time.sleep(1)
    21. print('当前鼠标位置： {}'.format(mouse.position))

    4.【鼠标点击和滚轮滚动】

    鼠标点击：可以直接用click()，也可以拆解按下press和释放release。

    鼠标滚轮滚动用：mouse.scroll(x, y)

    1. import time
    2. from pynput.mouse import Button, Controller
    3.  
    4. # 鼠标控制器
    5. mouse = Controller()
    6.  
    7. # 右击; 
    8. mouse.click(Button.right, 1)
    9. #说明：可以控制点击次数，这里1次。
    10.  
    11. # 按下和释放右键 === 等价于：右击
    12. mouse.press(Button.right)
    13. mouse.release(Button.right)
    14.  
    15. # 双击左键
    16. mouse.click(Button.left, 2)
    17. #说明：可以控制点击次数，双击这里传入2次。
    18.  
    19. # 滚动鼠标滚轮
    20. mouse.scroll(x, y)
    21. 说明：Mac电脑，y>0,向上滚动内容。y<0,向下滚动内容

    完整示例如下：

    1. import time
    2. from pynput.mouse import Button, Controller
    3.  
    4. # 鼠标控制器
    5. mouse = Controller()
    6.  
    7. # 移动到某个位置 (700, 300)为例
    8. mouse.position = (700, 300)
    9.  
    10. # 留点缓冲时间
    11. time.sleep(0.1)
    12.  
    13. # 向下滚动30单位
    14. mouse.scroll(0, -30)
    15.  
    16. # 按下和释放右键
    17. mouse.press(Button.right)
    18. mouse.release(Button.right)

    4.【鼠标监听，方式1】根据这种监听方式特点，方便区分，我给它命名为：listener监听方式。

    鼠标监听包括，鼠标移动、点击、滚轮滚动监听。

    完整示例代码如下

    1. from pynput import mouse
    2.  
    3. # 移动监听
    4. def on_move(x, y):
    5.     print('鼠标移动到了：{}'.format((x, y)))
    6.  
    7. # 点击监听
    8. def on_click(x, y, button, pressed):
    9.     print('鼠标按键：{}，在位置处 {}, {} '.format(button, (x, y), '按下了' if pressed else '释放了'))
    10.  
    11. # 滚动监听
    12. def on_scroll(x, y, dx, dy):
    13.     print('滚动中... {} 至 {}'.format('向下：' if dy < 0 else '向上：', (x, y)))
    14.  
    15.  
    16. # 构造监听器对象，方式1: （监听哪几种类型事件）
    17. with mouse.Listener(
    18.         on_move=on_move,
    19.         on_click=on_click,
    20.         on_scroll=on_scroll) as listener:
    21.  
    22.  
    23.  
    24.  
    25. # 构造监听器对象，方式2（可替换上面with）（监听哪几种类型事件）
    26. listener = mouse.Listener(
    27.     on_move=on_move,
    28.     on_click=on_click,
    29.     on_scroll=on_scroll)
    30.  
    31. # 开始监听
    32. listener.start()

    滚动、右击监听效果

    1. 说明：
    2. 1.构造监听器对象，有2种方式。任何一种方式均可。
    3.  
    4. # 构造监听器对象，方式1: （监听哪几种类型事件）
    5. with mouse.Listener(
    6.         on_move=on_move,
    7.         on_click=on_click,
    8.         on_scroll=on_scroll) as listener:
    9.     listener.join()
    10.  
    11.  
    12.  
    13. # 构造监听器对象，方式2（可替换上面with）（监听哪几种类型事件）
    14. listener = mouse.Listener(
    15.     on_move=on_move,
    16.     on_click=on_click,
    17.     on_scroll=on_scroll)
    18.  
    19.  
    20. 2.有了监听器对象，就开始监听，按是否阻断分为2种方式：
    21. # 监听启动方式1：阻断式
    22. listener.join()
    23.  
    24. # 监听启动方式2：非阻断式
    25. listener.start()
    26.  
    27. 3.停止监听：
    28. 任何位置调用pynput.mouse.Listener.stop 或者在上面3个回调方法中，只要有return False即可停止监听。

    6.【停止鼠标监听】

    任何位置调用pynput.mouse.Listener.stop 或者在回调方法中return False来停止监听。

    官方文档原文是：

    1. Call pynput.mouse.Listener.stop from anywhere, 
    2. raise StopException or return False from a callback to stop the listener.

    例如，我若想在点击监听回调里，释放时，停止监听。则可以这样写：

    1. def on_click(x, y, button, pressed):
    2.  print('鼠标按键：{}，在位置处 {}, {} '.format(button, (x, y), '按下了' if pressed else '释放了'))
    3.  if not pressed:
    4.       # 停止监听
    5.       return False

    7.【鼠标监听，方式2】根据这种监听方式特点，方便区分，我给它命名为：event监听方式。这种方式更简洁。

    注意写法区别上面的方式1的listener监听。

    1. from pynput import mouse
    2.  
    3.  
    4. with mouse.Events() as events:
    5.     for event in events:
    6.         if hasattr(event, 'button'):
    7.             deal = '按下了:' if event.pressed else '释放了:'
    8.             if event.button == mouse.Button.left:
    9.                 print('{}mouse.Button.left'.format(deal))
    10.  
    11.             elif event.button == mouse.Button.right:
    12.                 print('{} mouse.Button.right'.format(deal))
    13.  
    14.             elif event.button == mouse.Button.middle:
    15.  
    16.                 print('{} mouse.Button.middle'.format(deal))
    17.  
    18.             elif event.button == mouse.Button.unknown:
    19.                 print('{} mouse.Button.unknown'.format(deal))
    20.         else:
    21.             print('鼠标箭头：滑动中...')

    打印结果：

    1. 鼠标箭头：滑动中...
    2. 鼠标箭头：滑动中...
    3. 鼠标箭头：滑动中...
    4. 鼠标箭头：滑动中...
    5. 鼠标箭头：滑动中...
    6. 按下了:mouse.Button.left
    7. 释放了:mouse.Button.left
    8. 鼠标箭头：滑动中...
    9. 鼠标箭头：滑动中...
    10. 按下了: mouse.Button.right
    11. 释放了: mouse.Button.right

    1. 说明：
    2. 1.按下、释放都会被监听到。如果需要监听是按下还是释放，可以通过event对象的event.pressed来区分。
    3. 2.鼠标滑动时，event对象没有button属性。可以添加条件：if hasattr(event, 'button'):
    4. 有button属性则是点击了鼠标按钮。否则是鼠标箭头滑动。

    8.【键盘键入】导入核心类

    from pynput.keyboard import Key, Controller
    • 按下和释放键盘
    1. from pynput.keyboard import Key, Controller
    2.  
    3. # 键盘控制器
    4. keyboard = Controller()
    5.  
    6. # 按下和释放键盘，Key.space表示空格键
    7. keyboard.press(Key.space)
    8. keyboard.release(Key.space)
    • 键盘快速输入
    1. from pynput.keyboard import Key, Controller
    2.  
    3. # 键盘控制器
    4. keyboard = Controller()
    5.  
    6. # 输入，例如输入Hello World
    7. keyboard.type('Hello World')

    9.【键盘键入监听，方式1】根据此方式监听特点，且为了方便区分，我给它命名为listener方式。

    1. from pynput import keyboard
    2.  
    3.  
    4. def on_press(key):
    5.     try:
    6.         print('字母键： {} 被按下'.format(key.char))
    7.     except AttributeError:
    8.         print('特殊键： {} 被按下'.format(key))
    9.  
    10.  
    11. def on_release(key):
    12.     print('{} 释放了'.format(key))
    13.     if key == keyboard.Key.esc:
    14.         # 释放了esc 键，停止监听
    15.         return False
    16.  
    17.  
    18. # 方式1：构造监听器对象listener
    19. with keyboard.Listener(
    20.         on_press=on_press,
    21.         on_release=on_release) as listener:
    22.  
    23.  
    24. # 方式2：构造监听器对象listener
    25. listener = keyboard.Listener(
    26.     on_press=on_press,
    27.     on_release=on_release)
    28.  
    29. # 开始监听
    30. # 监听启动方式1：阻断式
    31. listener.join()
    32.  
    33. # 监听启动方式2：非阻断式
    34. listener.start()

    1. 说明：
    2. 1.构造监听器对象listener，有2种方式。任何一种方式均可。
    3.  
    4. # 方式1：构造监听器对象listener
    5. with keyboard.Listener(
    6.         on_press=on_press,
    7.         on_release=on_release) as listener:
    8.  
    9.  
    10. # 方式2：构造监听器对象listener
    11. listener = keyboard.Listener(
    12.     on_press=on_press,
    13.     on_release=on_release)
    14.  
    15.  
    16. 2.有了监听器对象，就开始监听，按是否阻断分为2种方式：
    17. # 监听启动方式1：阻断式
    18. listener.join()
    19.  
    20. # 监听启动方式2：非阻断式
    21. listener.start()
    22.  
    23. 3.停止监听：
    24. 任何位置调用pynput.keyboard.Listener.stop 或者在上面3个回调方法中，只要有return False即可停止监听。

    10.【键盘键入监听，方式2】根据此方式监听特点，给它命名为event方式。

    1. from pynput import keyboard
    2.  
    3.  
    4. # 监听键盘键入
    5. with keyboard.Events() as events:
    6.     for event in events:
    7.  
    8.         # 监听esc键，释放esc键，停止监听。
    9.         if event.key == keyboard.Key.esc:
    10.             print('接收到事件 {}, 停止监听'.format(event))
    11.             break
    12.         else:
    13.             if isinstance(event, keyboard.Events.Press):
    14.                 print('按下按键 {} '.format(event))
    15.             elif isinstance(event, keyboard.Events.Release):
    16.                 print('松开按键 {}'.format(event))
    17.  
    18.  
    19. ----------
    20.  
    21. 说明：
    22. 1.判断是按下键盘还是释放键盘，通过：
    23. if isinstance(event, keyboard.Events.Press):
    24.    print('按下按键 {} '.format(event))
    25. elif isinstance(event, keyboard.Events.Release):
    26.    print('松开按键 {}'.format(event))
    27.  
    28. 2.判断是哪个键，通过event.key，
    29. pynput.keyboard.Key类中定义了键盘中的所有键。
    30.  
    31. 3.上面，监听esc键，释放esc键，停止监听。

    打印结果：

    1. 按下按键 Press(key=Key.cmd_r) 
    2. 按下按键 Press(key=Key.space) 
    3. 松开按键 Release(key=Key.cmd_r)
    4. 松开按键 Release(key=Key.space)
    5. 按下按键 Press(key='h') 
    6. 松开按键 Release(key='h')
    7. 按下按键 Press(key='e') 
    8. 松开按键 Release(key='e')
    9. 按下按键 Press(key='l') 
    10. 松开按键 Release(key='l')
    11. 按下按键 Press(key='l') 
    12. 松开按键 Release(key='l')
    13. 按下按键 Press(key='o') 
    14. 松开按键 Release(key='o')
    15. 按下按键 Press(key=Key.space) 
    16. 松开按键 Release(key=Key.space)
    17. 按下按键 Press(key='w') 
    18. 松开按键 Release(key='w')
    19. 按下按键 Press(key='o') 
    20. 松开按键 Release(key='o')
    21. 按下按键 Press(key='r') 
    22. 松开按键 Release(key='r')
    23. 按下按键 Press(key='l') 
    24. 松开按键 Release(key='l')
    25. 按下按键 Press(key='d') 
    26. 松开按键 Release(key='d')

    hello world

    11.【同时监听鼠标、键盘】使用pynput包同时监听键盘消息和鼠标消息。上面键盘和鼠标的listener方式和event方式，都可用选择是阻断式还是非阻断式监听。

    1. # 监听启动方式1：阻断式
    2. listener.join()
    3.  
    4. # 监听启动方式2：非阻断式
    5. listener.start()

    程序调用监听器的join()方法后，即被阻塞，不再执行后面的语句，以这种方式启动监听器，只能监听在某个监听器的join()方法调用前已启动的监听器的消息。

    因此，除了最后一个监听器外，其他监听器不能用listener.join()的方式启动，只能用非阻塞的listener.start()的方式启动。最后一个监听器则应当以listener.join()的方式启动，以使程序执行被阻塞，防止程序直接结束。

  • 相关阅读:
    【C语言】指针传参引发的相关问题
    3D检测论文阅读简记
    软考高级及杭州E类人才申请经验分享
    Docker入门-上篇
    软件测试面试题及答案 这个可以免费白嫖的题库不要错过了
    C#定时任务框架Quartz.NET 简单Demo
    mediaPlayer MediaPlayer 读取 字节数组
    Python实现喷泉粒子系统（Win11）
    XSS 和 CSRF
    程序、进程与线程
  • 原文地址：https://blog.csdn.net/FL1768317420/article/details/136271654