Python中使用PyHook监听鼠标和键盘事件实例

合集下载

python实现键盘控制鼠标移动

python实现键盘控制⿏标移动玩QQ桌球游戏时，有时候⽤⿏标控制⿏标指针的微⼩移动⽐较费劲⼉，所以想写个程序，可以⽤键盘的上下左右键来控制⿏标的移动，每次只移动⼀个像素。

本脚本依赖pywin32、pyHook和pymouse这两个库，请⾃⾏安装。

代码中的pythoncom是pywin32库的⼀部分，运⾏脚本后，即可通过键盘的上下左右键控制⿏标移动了。

# -*- coding:utf-8 -*-# 左37 上38 右39 下40import pythoncomimport pyHookfrom pymouse import PyMousedef onKeyboardEvent(event):# 获取所按下按键的idkeyID = event.KeyID# 获取当前⿏标的坐标mouse = PyMouse()x, y = mouse.position()x = int(x)y = int(y)# 设定x和y的偏移量deltaX = 0deltaY = 0if keyID == 37:deltaX = -1elif keyID == 38:deltaY = -1elif keyID == 39:deltaX = 1elif keyID == 40:deltaY = 1else:return True# 移动⿏标mouse.move(x + deltaX, y + deltaY)return Truedef main():# 启动键盘事件的监听hm = pyHook.HookManager()hm.KeyDown = onKeyboardEventhm.HookKeyboard()pythoncom.PumpMessages()if __name__ == '__main__':main()以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

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

python监听、操作键盘⿏标库pynput详细教程§ 0.0.0 前⾔监听、操作⿏标、键盘是实现⾃动化的捷径，⽐如我⽤到了模拟键盘操作。

pynput是监听、操控⿏标和键盘的跨平台第三⽅python库。

你可以通过pip insnall pynput来安装。

安装时会⾃动下载依赖库。

接下来我会按“⿏标按键”“监听⿏标”“控制⿏标”，“键盘按键”“监听键盘”“控制键盘”的顺序介绍它的⽤法。

以下为正⽂。

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

每⼀个按键都有两个有意义的属性：name和value。

name是该按键的名称，⽐如 == 'left'；value是记录上⼀次点击位置的元组。

§1.1.0 监听⿏标有两种⽅法，⼀种是函数式、⾮阻塞型，另⼀种是语句式、阻塞型。

先说第⼀种，这种是常见的教程所说的⽅法。

§1.1.1 pynput.mouse.Listener以下是官⽹的说明⽰例：import pynput, timedef on_move(x, y):print('Pointer moved to {0}'.format((x, y)))def on_click(x, y, button, pressed):print('{0} at {1}'.format('Pressed' if pressed else 'Released',(x, y)))if not pressed:# Stop listenerreturn Falsedef on_scroll(x, y, dx, dy):print('Scrolled {0} at {1}'.format('down' if dy < 0 else 'up',(x, y)))# Collect events until releasedwith pynput.mouse.Listener(on_move=on_move,on_click=on_click,on_scroll=on_scroll) as listener:listener.join()运⾏这段代码时，移动⿏标会显⽰其坐标，按下⿏标按键并松开后，程序结束。

Python捕捉和模拟鼠标事件的方法

Python捕捉和模拟⿏标事件的⽅法本⽂实例讲述了Python捕捉和模拟⿏标事件的⽅法。

分享给⼤家供⼤家参考。

具体分析如下：这个假期玩了不少galgame，不过有些很⽼的游戏没有⾃动运⾏模式，点击⿏标⼜太伤按键了，于是想把滚动⿏标滚轮映射为点击⿏标。

⽹上搜了⼀下，没发现什么现成的软件，⽽按键精灵⼜太重量级了，于是考虑⼲脆⾃⼰⽤Python写个算了。

这⾥需要把PyHook和PyWin32都装上（建议下exe版，免得安装时各种蛋疼）。

翻了翻教程，发现实现起来很简单：# -*- coding: utf-8 -*-import pythoncom, pyHookdef OnMouseEvent(event):print 'MessageName:',event.MessageNameprint 'Message:',event.Messageprint 'Time:',event.Timeprint 'Window:',event.Windowprint 'WindowName:',event.WindowNameprint 'Position:',event.Positionprint 'Wheel:',event.Wheelprint 'Injected:',event.Injectedprint '---'# 返回 True 可将事件传给其它处理程序，否则停⽌传播事件return True# 创建钩⼦管理对象hm = pyHook.HookManager()# 监听所有⿏标事件hm.MouseAll = OnMouseEvent # 等效于hm.SubscribeMouseAll(OnMouseEvent)# 开始监听⿏标事件hm.HookMouse()# ⼀直监听，直到⼿动退出程序pythoncom.PumpMessages()这个例⼦程序捕捉了所有的⿏标事件，实际上我只需要捕捉向下滚动滚轮的事件即可。

pynput用法

pynput用法pynput是一个Python库，用于控制和监视鼠标和键盘。

它的使用主要涉及以下部分：•Controller类：这个类可以用来控制鼠标和键盘。

例如，你可以创建一个Controller 对象，然后使用这个对象来控制鼠标或键盘。

•Button模块：这个模块包含左键、右键和中键操作。

以下是一些使用pynput的示例：1.获取或设置鼠标位置：python复制代码import pynputfrom pynput.mouse import Controller, Buttonmouse = Controller()# 获取鼠标当前的位置mouse_position = mouse.positionprint("鼠标当前的位置是:{0}".format(mouse_position))# 获取鼠标x轴当前的位置x, y = mouse.positionprint("鼠标x轴当前的位置是:{},鼠标y轴当前的位置是:{}".format(x,y))# 修改鼠标位置mouse_position = (490,500)mouse.position = mouse_positionprint("修改后鼠标位置:{0}".format(mouse_position))2.鼠标执行点击和松开操作：python复制代码import pynput.mouse as mouseimport timeprint("请在2秒内移动到需要点击的位置。

")time.sleep(2)mouse_position=mouse.positionprint("需要点击的位置是:{0}".format(mouse_position))mouse.click(Button.left) #左键点击3.移动鼠标：python复制代码import pynput.mouse as mouse# 移动到绝对坐标（x，y）处mouse.move(x, y)注意：在以上代码中，x和y的值是你想要鼠标移动到的位置。

Python监控键盘输入鼠标操作并将捕获到的信息记录到文件中

Python监控键盘输入鼠标操作并将捕获到的信息记录到文件中在Python中，可以使用第三方库`pynput`来监控键盘输入和鼠标操作，并将捕获到的信息记录到文件中。

下面是一个1200字以上的示例代码，演示了如何使用`pynput`库来实现键盘和鼠标监听，并将捕获到的信息写入文件中。

```pythonfrom pynput import keyboard, mouse#创建一个日志文件log_file = open("log.txt", "w")#记录键盘输入信息的回调函数def on_keyboard_press(key):try:log_file.write("键盘按下: {0}\n".format(key.char))except AttributeError:log_file.write("特殊键按下: {0}\n".format(key))def on_keyboard_release(key):log_file.write("键盘释放: {0}\n".format(key))#键盘监听器keyboard_listener =keyboard.Listener(on_press=on_keyboard_press,on_release=on_keyboard_release)keyboard_listener.start#记录鼠标操作信息的回调函数def on_mouse_move(x, y):log_file.write("鼠标移动到: ({0}, {1})\n".format(x, y))def on_mouse_click(x, y, button, pressed):if pressed:log_file.write("鼠标点击: ({0}, {1}) [{2}]\n".format(x, y, button))else:log_file.write("鼠标释放: ({0}, {1}) [{2}]\n".format(x, y, button))def on_mouse_scroll(x, y, dx, dy):log_file.write("鼠标滚动: ({0}, {1}) 滚动 ({2},{3})\n".format(x, y, dx, dy))#鼠标监听器mouse_listener = mouse.Listener(on_move=on_mouse_move,on_click=on_mouse_click, on_scroll=on_mouse_scroll)mouse_listener.start#程序运行keyboard_listener.joinmouse_listener.join#关闭日志文件log_file.close```上述代码中，我们首先导入`keyboard`和`mouse`模块，用于创建键盘监听器和鼠标监听器。

Python监听键盘和鼠标事件的示例代码

Python监听键盘和⿏标事件的⽰例代码我们可以利⽤windows提供的api函数来实现对系统键盘事件和⿏标事件的监听，主要利⽤的是SetWindowsHookEx函数，这个函数可以允许调⽤者传⼊⼀个钩⼦函数也叫回调函数，当指定的事件发⽣时，你传⼊的函数就会被触发，有些事件是进程级的，有些事件是系统级的，这⾥我们⽤WH_KEYBOARD_LL来监听系统键盘事件，⽤WH_MOUSE_LL来监听⿏标事件，注意不是WH_KEYBOARD，使⽤WH_KEYBOARD是⽆法监听到外部程序的事件的，这个可以在windows官⽅⽂档⾥⾯看到说明，要⽤WH_KEYBOARD来监听系统键盘必须写dll去实现。

因为⽤到了⼀些宏定义在win32con⾥⾯已经有了，所以需要安装⼀下pypiwin32，当然如果你将这些宏定义写在⾃⼰的⽂件中，那么就不⽤安装pypiwin32了。

安装pypiwin32pip install pypiwin32# coding=utf-8from ctypes import *from ctypes import wintypesimport win32conSetWindowsHookEx=er32.SetWindowsHookExAUnhookWindowsHookEx=er32.UnhookWindowsHookExCallNextHookEx=er32.CallNextHookExGetMessage=er32.GetMessageAGetModuleHandle=windll.kernel32.GetModuleHandleW#保存键盘钩⼦函数句柄keyboard_hd = None#保存⿏标钩⼦函数句柄mouse_hd = Noneclass KBDLLHOOKSTRUCT(Structure):_fields_ = [('vkCode',c_int),('scanCode', c_int),('flags', c_int),('time', c_int),('dwExtraInfo', c_uint),('',c_void_p)]class POINT(Structure):_fields_ = [('x',c_long),('y',c_long)]class MSLLHOOKSTRUCT(Structure):_fields_ = [('pt',POINT),('hwnd',c_int),('wHitTestCode',c_uint),('dwExtraInfo',c_uint),]def wait_for_msg():msg = wintypes.MSG()GetMessage(msg, 0, 0, 0)def keyboard_pro(nCode, wParam, lParam):"""函数功能：键盘钩⼦函数，当有按键按下时此函数被回调"""if nCode == win32con.HC_ACTION:KBDLLHOOKSTRUCT_p = POINTER(KBDLLHOOKSTRUCT)param=cast(lParam,KBDLLHOOKSTRUCT_p)print(param.contents.vkCode)return CallNextHookEx(keyboard_hd, nCode, wParam, lParam)def start_keyboard_hook():"""函数功能：启动键盘监听"""HOOKPROTYPE = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_void_p))pointer = HOOKPROTYPE(keyboard_pro)keyboard_hd = SetWindowsHookEx(win32con.WH_KEYBOARD_LL,pointer,GetModuleHandle(None),0)wait_for_msg()def stop_keyboard_hook():"""函数功能：停⽌键盘监听"""UnhookWindowsHookEx(keyboard_hd)def mouse_pro(nCode, wParam, lParam):"""函数功能：⿏标钩⼦函数，当有⿏标事件，此函数被回调"""if nCode == win32con.HC_ACTION:MSLLHOOKSTRUCT_p = POINTER(MSLLHOOKSTRUCT)param=cast(lParam,MSLLHOOKSTRUCT_p)#⿏标左键点击if wParam == win32con.WM_LBUTTONDOWN:print("左键点击，坐标：x:%d,y:%d" % (param.contents.pt.x,param.contents.pt.y))elif wParam == win32con.WM_LBUTTONUP:print("左键抬起，坐标：x:%d,y:%d" % (param.contents.pt.x, param.contents.pt.y))elif wParam == win32con.WM_MOUSEMOVE:print("⿏标移动，坐标：x:%d,y:%d" % (param.contents.pt.x, param.contents.pt.y))elif wParam == win32con.WM_RBUTTONDOWN:print("右键点击，坐标：x:%d,y:%d" % (param.contents.pt.x, param.contents.pt.y))elif wParam == win32con.WM_RBUTTONUP:print("右键抬起，坐标：x:%d,y:%d" % (param.contents.pt.x, param.contents.pt.y))return CallNextHookEx(mouse_hd, nCode, wParam, lParam)def start_mouse_hook():"""函数功能：启动⿏标监听"""HOOKPROTYPE = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_void_p))pointer = HOOKPROTYPE(mouse_pro)mouse_hd = SetWindowsHookEx(win32con.WH_MOUSE_LL,pointer,GetModuleHandle(None),0)wait_for_msg()def stop_mouse_hook():"""函数功能：停⽌⿏标监听"""UnhookWindowsHookEx(mouse_hd)测试代码：import HookApiif __name__== '__main__':HookApi.start_keyboard_hook()运⾏效果以上就是Python监听键盘和⿏标事件的⽰例代码的详细内容，更多关于Python监听键盘和⿏标事件的资料请关注其它相关⽂章！。

c#使用hook来监控鼠标键盘事件的示例代码

c#使⽤hook来监控⿏标键盘事件的⽰例代码如果这个程序在10⼏年前,QQ刚刚兴起的时候,有了这个代码,就可实现盗号了.当然使⽤钩⼦我们更多的是实现"全局快捷键"的需求.⽐如程序最⼩化隐藏后要"某快捷键"来启动它.钩⼦(hook),通俗的讲,她可以捕获到你的键盘和⿏标的相关操作消息.关于hook的相关代码⽹上⼀搜⼀箩筐,这是整理起来⽐较完善和使⽤最⽅便的.//Declare wrapper managed POINT class.[StructLayout(LayoutKind.Sequential)]public class POINT{public int x;public int y;}//Declare wrapper managed MouseHookStruct class.[StructLayout(LayoutKind.Sequential)]public class MouseHookStruct{public POINT pt;public int hwnd;public int wHitTestCode;public int dwExtraInfo;}//Declare wrapper managed KeyboardHookStruct class.[StructLayout(LayoutKind.Sequential)]public class KeyboardHookStruct{public int vkCode; //Specifies a virtual-key code. The code must be a value in the range 1 to 254.public int scanCode; // Specifies a hardware scan code for the key.public int flags; // Specifies the extended-key flag, event-injected flag, context code, and transition-state flag.public int time; // Specifies the time stamp for this message.public int dwExtraInfo; // Specifies extra information associated with the message.}public class GlobalHook{public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);public delegate int GlobalHookProc(int nCode, Int32 wParam, IntPtr lParam);public GlobalHook(){//Start();}~GlobalHook(){Stop();}public event MouseEventHandler OnMouseActivity;public event KeyEventHandler KeyDown;public event KeyPressEventHandler KeyPress;public event KeyEventHandler KeyUp;/// <summary>/// 定义⿏标钩⼦句柄./// </summary>static int _hMouseHook = 0;/// <summary>/// 定义键盘钩⼦句柄/// </summary>static int _hKeyboardHook = 0;public int HMouseHook{get { return _hMouseHook; }}public int HKeyboardHook{get { return _hKeyboardHook; }}/// <summary>/// ⿏标钩⼦常量(from Microsoft SDK Winuser.h )/// </summary>public const int WH_MOUSE_LL = 14;/// <summary>/// 键盘钩⼦常量(from Microsoft SDK Winuser.h )/// </summary>public const int WH_KEYBOARD_LL = 13;/// <summary>/// 定义⿏标处理过程的委托对象/// </summary>GlobalHookProc MouseHookProcedure;/// <summary>/// 键盘处理过程的委托对象/// </summary>GlobalHookProc KeyboardHookProcedure;//导⼊window 钩⼦扩展⽅法导⼊/// <summary>/// 安装钩⼦⽅法/// </summary>[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]public static extern int SetWindowsHookEx(int idHook, GlobalHookProc lpfn,IntPtr hInstance, int threadId);/// <summary>/// 卸载钩⼦⽅法/// </summary>[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]public static extern bool UnhookWindowsHookEx(int idHook);//Import for CallNextHookEx./// <summary>/// 使⽤这个函数钩信息传递给链中的下⼀个钩⼦过程。

Python键盘鼠标控制

Python键盘鼠标控制键盘控制需要用到keyboard模块（pip install keyboard)按键字符#字符'1''a'...#控制'ctrl''alt''shift''enter''esc''f1'...#方向键'up''down''left''right'#组合按键'ctrl'+'alt'+'a'...常用方法wait()监听按键，如果没设置按键，将会一直监听这句之前的按键；如果设置了按键，那么在按下该按键后就会停止监听，并执行后面的语句，举例：import keyboardprint(0)keyboard.wait('a')#在按下a之前后面的语句都不会执行，下面同理print(1)keyboard.wait('b')print(2)keyboard.wait('c')print(3)keyboard.wait()结果：0123#继续监听#只有按顺序按下abc（中间过程随便按不干扰）才能输出0123，但因为最后一个没设置按键，所以会一直监听下去add_hotkey()设置热键，一般和wait()组合使用，在wait监听下，当按下热键时会执行对应函数，举例：import keyboard #监听键盘def test_a():print('aaa')def test(x):print(x)if __name__ == '__main__':keyboard.add_hotkey('f1', test_a)#按f1输出aaakeyboard.add_hotkey('ctrl+alt', test, args=('b',))#按ctrl+alt输出bkeyboard.wait()#wait里也可以设置按键，说明当按到该键时结束record()记录键盘事件，如果加上until参数，可以设置当按下某按键时结束监听，和wait方法有点像，举例：import keyboardkeyboard.add_hotkey('ctrl', print, args=('aaa',))keyboard.add_hotkey('alt', print, args=('bbb',))recorded = keyboard.record(until='esc')#当按下esc时结束按键监听，并输出所有按键事件print(recorded)结果为：aaaaaabbb[KeyboardEvent(ctrl down), KeyboardEvent(ctrl up), KeyboardEvent(ctrl down),KeyboardEvent(ctrl up), KeyboardEvent(alt down), KeyboardEvent(alt up),KeyboardEvent(esc down)]hook()绑定所有按键事件，当只要有按键按下/松开时就会触发的回调函数，举例：import keyboarddef abc(x):print(x)print("111")keyboard.hook(abc)#按下任何按键时，都会调用abc，其中一定会传一个值，就是键盘事件keyboard.wait()结果：KeyboardEvent(w down)111KeyboardEvent(w up)111KeyboardEvent(space down)111KeyboardEvent(space up)111KeyboardEvent(tab down)111KeyboardEvent(tab up)111KeyboardEvent(ctrl down)111...KeyboardEvent()一个按键事件，里面有3个常用参数：event_type、scan_code、name，分别代表按键类型（down/up）、按键号（每个键都有对应的）和按键名，举例：import keyboarddef abc(x):a = keyboard.KeyboardEvent('down', 28, 'enter')#按键事件a为按下enter键，第二个参数如果不知道每个按键的值就随便写，#如果想知道按键的值可以用hook绑定所有事件后，输出x.scan_code即可if x.event_type == 'down' and == :print("你按下了enter键")#当监听的事件为enter键，且是按下的时候keyboard.hook(abc)# keyboard.hook_key('enter', bcd)# recorded = keyboard.record(until='esc')keyboard.wait()结果：你按下了enter键你按下了enter键更多参考鼠标控制需要用到pyautogui模块（pip install pyautogui）常用方法position()获取鼠标位置，举例：import pyautogui as pag #监听鼠标x1, y1 = pag.position()print(x1, y1)#输出鼠标当前位置实例-结合鼠标键盘截图（按下两次alt+ctrl来确定图片左上角和右上角，然后截图保存）import keyboard #监听键盘import pyautogui as pag #监听鼠标from PIL import ImageGrab #截图、读取图片、保存图片if keyboard.wait(hotkey='ctrl+alt') == None:x1, y1 = pag.position()if keyboard.wait(hotkey='ctrl+alt') == None:x2, y2 = pag.position()image = ImageGrab.grab((x1, y1, x2, y2))image.save("screen.png")click()鼠标点击控制，举例：import pyautoguipyautogui.click(button='right')#点击鼠标右键pyautogui.click(100, 100)#要在指定位置点击左键。

使用PythonHook做Hook

PyHook是一个基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。

这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。

关于PyHook的使用，在它的官方主页上就有一个简单的教程，大体上来说，可以这样使用：01 # -*- coding: utf-8 -*-02 #03 # by oldj04 # /05 #0607 import pythoncom08 import pyHook0910 def onMouseEvent(event):11 # 监听鼠标事件12 print "MessageName:", event.MessageName13 print "Message:", event.Message14 print "Time:", event.Time15 print "Window:", event.Window16 print "WindowName:", event.WindowName17 print "Position:", event.Position18 print "Wheel:", event.Wheel19 print "Injected:", event.Injected20 print "---"2122 # 返回 True 以便将事件传给其它处理程序23 # 注意，这儿如果返回 False ，则鼠标事件将被全部拦截24 # 也就是说你的鼠标看起来会僵在那儿，似乎失去响应了25 return True2627 def onKeyboardEvent(event):28 # 监听键盘事件29 print "MessageName:", event.MessageName30 print "Message:", event.Message31 print "Time:", event.Time32 print "Window:", event.Window33 print "WindowName:", event.WindowName34 print "Ascii:", event.Ascii, chr(event.Ascii)35 print "Key:", event.Key36 print "KeyID:", event.KeyID37 print "ScanCode:", event.ScanCode38 print "Extended:", event.Extended39 print "Injected:", event.Injected40 print "Alt", event.Alt41 print "Transition", event.Transition42 print "---"4344 # 同鼠标事件监听函数的返回值45 return True4647 def main():48 # 创建一个“钩子”管理对象49 hm = pyHook.HookManager()5051 # 监听所有键盘事件52 hm.KeyDown = onKeyboardEvent53 # 设置键盘“钩子”54 hm.HookKeyboard()5556 # 监听所有鼠标事件57 hm.MouseAll = onMouseEvent58 # 设置鼠标“钩子”59 hm.HookMouse()6061 # 进入循环，如不手动关闭，程序将一直处于监听状态62 pythoncom.PumpMessages()6364 if __name__ == "__main__":65 main()运行上面的脚本，试试看移动一下鼠标，或者按一下键盘（比如开一个记事本程序，随便写点东西），看看这个脚本输出了什么。

pynput库用法

pynput库用法pynput 是一个 Python 库，用于监听和控制输入设备，例如键盘和鼠标。

以下是 pynput 库的一些基本用法示例：安装 pynput 库：pip install pynput监听键盘输入：from pynput import keyboarddef on_press(key):try:print('Key {0} pressed.'.format(key.char))except AttributeError:print('Special key {0} pressed.'.format(key))def on_release(key):print('Key {0} released.'.format(key))if key == keyboard.Key.esc:# 停止监听return False# 设置监听with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:listener.join()监听鼠标输入：from pynput import mousedef on_move(x, y):print('Mouse moved to ({0}, {1})'.format(x, y))def on_click(x, y, button, pressed):action = 'Pressed' if pressed else 'Released'print('{0} at ({1}, {2}) with {3}'.format(action, x, y, button))def on_scroll(x, y, dx, dy):print('Scrolled {0} at ({1}, {2}) ({3}, {4})'.format('down' if dy < 0 else 'up', x, y, dx, dy))# 设置监听with mouse.Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as listener:listener.join()这是一个简单的示例，pynput 提供了更多的功能，可以根据具体需求进行更复杂的键盘和鼠标操作。

Python：监控键盘输入、鼠标操作，并将捕获到的信息记录到文件中

Python：监控键盘输入、鼠标操作，并将捕获到的信息记录到文件中PyHook是一个基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。

这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。

使用pyhook模块可以很快地完成键盘及鼠标事件捕获，此模块可从files/pyhook/1.5.1/下载，API手册：，网站上提供了个使用的例子，改写了下，将信息记录到文件中，本来想使用python的logging模块，但测试时发现，因为鼠标事件频率太高，导致写时报I/O错误的异常，所以使用了自己写文件记录日志的方式。

弄了一早上，不知道为什么是我的pyHook有问题还是我的python2.7环境有问题，在运行时老是出现_cpyHook模块不存在，当好不容易在网上找到这个文件后放在Dll目录下后，还是报错，说什么编问题。

本人是菜鸟级别pythoner，由于时间问题没问题还没解决，请高手过目下面代码，有意者测试一下，欢迎交流！参考详细链接：1./dyx1024/article/details/73110132./code/snippet_201076_93253./apps/mediawiki/pyhook/index.php?title=PyHook_Tutorial#!/usr/bin/env python# -*- coding: utf-8 -*-import pythoncomimport pyHookimport timedef onMouseEvent(event):"处理鼠标事件"fobj.writelines('-' * 20 + 'MouseEvent Begin' + '-' * 20 + '\n') fobj.writelines("Current Time:%s\n" % time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime())) fobj.writelines("MessageName:%s\n" % str(event.MessageName))fobj.writelines("Message:%d\n" % event.Message)fobj.writelines("Time_sec:%d\n" % event.Time)fobj.writelines("Window:%s\n" % str(event.Window))fobj.writelines("WindowName:%s\n" % str(event.WindowName))fobj.writelines("Position:%s\n" % str(event.Position))fobj.writelines('-' * 20 + 'MouseEvent End' + '-' * 20 + '\n') return Truedef onKeyboardEvent(event):"处理键盘事件"fobj.writelines('-' * 20 + 'Keyboard Begin' + '-' * 20 + '\n')fobj.writelines("Current Time:%s\n" % time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime())) fobj.writelines("MessageName:%s\n" % str(event.MessageName))fobj.writelines("Message:%d\n" % event.Message)fobj.writelines("Time:%d\n" % event.Time)fobj.writelines("Window:%s\n" % str(event.Window))fobj.writelines("WindowName:%s\n" % str(event.WindowName))fobj.writelines("Ascii_code: %d\n" % event.Ascii)fobj.writelines("Ascii_char:%s\n" % chr(event.Ascii))fobj.writelines("Key:%s\n" % str(event.Key))fobj.writelines('-' * 20 + 'Keyboard End' + '-' * 20 + '\n')return Trueif __name__ == "__main__":'''Function:监控键盘输入、鼠标操作，并将捕获到的信息记录到文件中Input：NONEOutput: NONEauthor: socratesblog:/kaiyongdengdate:2012-03-16'''#打开日志文件file_name = "D:\\hook_log.txt"fobj = open(file_name, 'w')#创建hook句柄hm = pyHook.HookManager()#监控键盘hm.KeyDown = onKeyboardEventhm.HookKeyboard()#监控鼠标hm.MouseAll = onMouseEvent hm.HookMouse()#循环获取消息pythoncom.PumpMessages()#关闭日志文件fobj.close()。

python使用pynput库操作、监控你的鼠标和键盘

python使用pynput库操作、监控你的鼠标和键盘楔子python是一门很神奇的语言，原因在于它有很多的库可以实现各种意想不到的功能。

当然我们这次介绍的库所实现的功能却是已经很常见了，就是操作、监控你的鼠标和键盘。

如果你写过游戏，那么即使不用下面即将介绍的库也可以实现对鼠标、键盘的操作以及监控。

当然我们下面介绍库：pynput，是专门针对鼠标和键盘的，至于pygame、pyglet等游戏框架虽然也提供了鼠标、键盘的监控事件，但它们毕竟是用来开发游戏的，还提供了创建窗口、图形绘制、物体的碰撞检测等等很多复杂的功能。

如果只是单纯的操作鼠标和键盘，使用这种游戏框架有点小题大做了，下面我们就来看看这个名叫pynput的模块吧，看看它的使用方法。

鼠标操作鼠标鼠标无非就是'点击按住不放'、'松开'、'双击'(针对左右键)，滑动滚轮，移动鼠标等等，这些功能已经基本上覆盖百分之八九十的日常使用了。

至于剩下的一小部分，可能就是打游戏用到的'侧键'，但是我们不介绍那么多，先来看看常用的吧。

from pynput.mouse import Button, Controller # 实例化Controller得到一个可以操作鼠标的对象mouse = Controller() # mouse.position: 获取当前鼠标位置。

# 屏幕左上角坐标为(0, 0) 右下角为(屏幕宽度, 屏幕高度) print(f'当前鼠标位置: {mouse.position}') # 当前鼠标位置: (881, 467) # 给mouse.position赋值等于移动鼠标，这里相当于移动到(100, 100)的位置 # 如果坐标小于0，那么等于0。

如果超出屏幕范围，那么等于最大范围 mouse.position = (100, 100) # 此方法等价于mouse.move(100, 100) print(f'当前鼠标位置: {mouse.position}') # 当前鼠标位置: (100, 100) # 按下左键,同理Button.right是右键mouse.press(Button.left) # 松开左键mouse.release(Button.left) # 上面两行连在一起等于一次单击。

【python】python控制鼠标和键盘

【python】python控制⿏标和键盘安装pymouse需要安装⼀些其他的包，否则运⾏时候会报错！需要安装pyHook和PyUserinput其中pyHook貌似不能之间pip安装，下⾯的⽹站有很多Windows依赖包。

找到如下的插件，然后对应⾃⼰电脑的Python版本下载.whl⽂件。

安装好了pyHook之后，需要安装PyUserinput直接执⾏pip install PyUserinput就了最后安装pymouse，⽤pip install pymouse下载就能导⼊。

from pymouse import PyMouse导⼊pykeyboard也是⼀样 from pykeyboard import PyKeyboard貌似pymouse和pykeyboard都集成到了pyuserinput中了，安装了pyuserinput就⽆需pip安装PyMouse了。

如果导⼊失败，可以单独再安装⼀边，⽤pip install pumouse和pip install pukeyboardPyMouse的⽤法from pymouse import PyMousemyMouse = PyMouse()#获取当前的⿏标位置nowP = myMouse.position()print(nowP)#⿏标移动到坐标(x,y)处myMouse.move(x,y)#⿏标点击，x,y是坐标位置 button 1表⽰左键，2表⽰点击右键 n是点击次数，默认是1次，2表⽰双击#myMouse.click(x,y,button,n)#最简单的⽤法myMouse.click(x,y)PyKeyboard的⽤法键盘：k.type_string(‘Hello, World!’) –模拟键盘输⼊字符串k.press_key(‘H’) –模拟键盘按H键k.release_key(‘H’) –模拟键盘松开H键k.tap_key(“H”) –模拟点击H键k.tap_key(‘H’,n=2,interval=5) –模拟点击H键，2次，每次间隔5秒k.tap_key(k.function_keys[5]) –点击功能键F5k.tap_key(k.numpad_keys[5],3) –点击⼩键盘5,3次组合键:例如同时按alt+tab键盘k.press_key(k.alt_key) –按住alt键k.tap_key(k.tab_key) –点击tab键k.tap_key(k.enter_key) -点击回车键k.release_key(k.alt_key) –松开alt键。

python模拟鼠标点击和键盘输入的操作

python模拟⿏标点击和键盘输⼊的操作所有代码都是⽹上百度出来的，通过个⼈实践找到适合⾃⼰的。

采⽤的python 库是 pymouse、pykeyboard安装时直接pip安装的，pip install PyUserInput实现了⼀个最简单的输⼊密码，enter进⼊的登录过程如果想遍历，可以使⽤itertools 包，很有⽤，具体⽤法这⾥不介绍了。

· ⿏标点击有m.click(x, y, button, n) -- 点击，想x,y坐标，button：-1表⽰左键，-2表⽰右键，n：默认1次，2双击m.move(x, y) -- ⿏标移动m.screen_size() -- 获取屏幕尺⼨· 键盘操作k.type_string('abcdefg') --输⼊内容k.press_key('a') --按a键k.release_key('a') --松开a键k.tap_key('a') --点击a键k.tap_key('a', n=2, interval=5) --点击a键2次，每次间隔5秒k.tap_key(k.function_keys[5]) --功能键F5k.press_keys([k.alt_key, 'a']) --组合按键，试验不成功win10 系统没反应关于监听键盘操作窗⼝：import pyHookimport pythoncom需要⽤到这两个模块，安装⽅法可以⽹上百度，我下载的是pyHook-1.5.1-cp27-cp27m-win_amd64.whl,放到python安装⽬录Scripts 下，执⾏pip install pyHook-1.5.1-cp27-cp27m-win_amd64.whl即可其中ctypes⽐较复杂，会单独写⼀篇运⾏结果如下，可以把输⼊的内容保存到⼀个⽂档中（例えば：txt/excel）这是两张图⽚拼出来的，拼接处有些明显，具体实现如下import Imageimage1 = Image.open('C:\\Pictures\\csdn\\1.png'.decode('utf8').encode('gbk')) #如果是中⽂路径image1 = Image.open('C:\\Pictures\\csdn\\2.png'.decode('utf8').encode('gbk'))w1,h1 = image1.sizew2,h2 = image2.sizenewIm= Image.new('RGB', (max(w1,w2), h1+h2+1), 'white')newIm.paste(image1,(0,0))newIm.paste(image2,(0,h1))newIm.save('C:\\Pictures\\csdn\\Image.png','jpeg')还是挺简单的。

python中使用pyhook实现键盘监控的例子

python中使⽤pyhook实现键盘监控的例⼦以上⽹站上提供了⼏个使⽤的例⼦，另外安装pyhooks后，也会有⼀个例⼦的⽂件。

于是拿来学习了⼀下，第⼀次运⾏时，提⽰没有pythoncom模块，就安装了pywin32，安装后，可以正常运⾏，但是会导致机器发卡，特别是中断程序运⾏后，⿏标会出现⼀段时间的⾃由晃动，找了半天原因，感觉主要是事件频率过⾼，程序会经常卡在pythoncom.PumpMessages()。

⽹上搜索了半天，看到有⼀帖⼦说是pythoncom.PumpMessages(n)，n表⽰延迟时间，于是试着改了下，发现有⼀定效果，但不明显，后来想是不是因为没有终⽌程序，才会导致⼀直很卡呢，于是添加终⽌程序语句win32api.PostQuitMessage()。

结果还算满意。

# -*- coding: cp936 -*-import pythoncomimport pyHookimport timeimport win32apit=''asciistr=''keystr=''def onKeyboardEvent(event):global t,asciistr,keystrfilename='d://test.txt'wrfile=open(filename,'ab')"处理键盘事件"if t==str(event.WindowName):asciistr=asciistr+chr(event.Ascii)keystr=keystr+str(event.Key)else:t=str(event.WindowName)if asciistr=='' and keystr=='':wrfile.writelines("\nWindow:%s\n" % str(event.Window))wrfile.writelines("WindowName:%s\n" % str(event.WindowName)) #写⼊当前窗体名wrfile.writelines("MessageName:%s\n" % str(event.MessageName))wrfile.writelines("Message:%d\n" % event.Message)wrfile.writelines("Time:%s\n" % time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))else:wrfile.writelines("Ascii_char:%s\n" %asciistr)wrfile.writelines("Key_char:%s\n" %keystr)wrfile.writelines("\nWindow:%s\n" % str(event.Window))wrfile.writelines("WindowName:%s\n" % str(event.WindowName)) #写⼊当前窗体名wrfile.writelines("Time:%s\n" % time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))asciistr=chr(event.Ascii)keystr=str(event.Key)if str(event.Key)=='F12': #按下F12后终⽌wrfile.writelines("Ascii_char:%s\n" %asciistr)wrfile.writelines("Key_char:%s\n" %keystr)wrfile.close()win32api.PostQuitMessage()return Trueif __name__ == "__main__":#创建hook句柄hm = pyHook.HookManager()#监控键盘hm.KeyDown = onKeyboardEventhm.HookKeyboard()#循环获取消息pythoncom.PumpMessages(10000)。

利用Python实现Windows下的鼠标键盘模拟的实例代码

利⽤Python实现Windows下的⿏标键盘模拟的实例代码本⽂介绍了利⽤Python实现Windows下的⿏标键盘模拟的实例代码，分享给⼤家本来⽤按键精灵是可以实现我的需求，⽽且更简单，但既然学python ，就看⼀下呗。

依赖：pip install PyUserInputPyUserInput 依赖 pyhook，所以还得安装 pyhook。

按需下载，。

我是 win10 64 位 python 2.7，⽤的是第⼆个，下载之后⽤解压软件打开，把 pyHook放到C:\Python27\Lib\site-packages\pyHook下即可。

环境有了，看⼀下代码。

模拟⿏标from pymouse import *m = PyMouse()m.click(1806, 14)m.click(x,y,button,n) #⿏标点击#x,y #是坐标位置#button #1表⽰左键，2表⽰点击右键#n –点击次数，默认是1次，2表⽰双击m.click(577, 490, 1)⽐较简单，看⼀下⿏标事件监控：class Clickonacci(PyMouseEvent):def __init__(self):PyMouseEvent.__init__(self)def click(self, x, y, button, press):print(time.time(), button, press)c = Clickonacci()c.run()这⾥要注意是阻塞线程的。

模拟键盘from pykeyboard import *k = PyKeyboard()k.type_string(u'杀毒防御') # 我靠不能输⼊中⽂啊。

k.press_key('H') # 模拟键盘按H键k.release_key('H') # 模拟键盘松开H键k.tap_key('H') # 模拟点击H键k.tap_key('H', n=2, interval=5) # 模拟点击H键，2次，每次间隔5秒k.tap_key(k.function_keys[5]) # 点击功能键F5#组合键模拟#例如同时按alt+tab键盘k.press_key(k.alt_key) # 按住alt键k.tap_key(k.tab_key) # 点击tab键k.release_key(k.alt_key) # 松开alt键键盘事件监听：class TapRecord(PyKeyboardEvent):def __init__(self):PyKeyboardEvent.__init__(self)def tap(self, keycode, character, press):print(time.time(), keycode, character, press)t = TapRecord()t.run()嗯，本来我是想整点东西的，但后来发现 360 太猛了，对360的窗⼝都⽆效，其他倒是不影响。

python对绑定事件的鼠标、按键的判断实例

python对绑定事件的⿏标、按键的判断实例当多个事件绑定了同⼀个命令，那么在命令内部根据不同的事件进⾏处理的时候，怎么确定哪个事件发⽣了呢，⽤下⾯的来检测，经过测试处理tab键和alt键不能识别，其他单个都能被识别。

还有个事件的type属性，这个经过测试键盘事件返回字符2，⿏标返回字符2，可以根据这个再进⾏判断反会的是键盘事件还是⿏标事件。

# <Button-1>：⿏标左击事件# <Button-2>：⿏标中击事件# <Button-3>：⿏标右击事件# <Double-Button-1>：双击事件# <Triple-Button-1>：三击事件from tkinter import *tk = Tk()canvas = Canvas(width=500,height=500)canvas.pack()#canvas.create_polygon(0,0,250,250,fill = 'red')def echo_event(evt):#打印键盘事件if evt.type == "2":print("键盘：%s" % evt.keysym)#打印⿏标操作if evt.type == "4":print("⿏标： %s" % evt.num)#print(evt.type)#键盘事件canvas.bind_all("<KeyPress>",echo_event)#如果绑定指定的键盘，则"<Key>" 或者"<KeyPress>"都可以，具体到指定键的话后⾯加⼊下划线和指定的键就好了，如：绑定⼩写字母t和Left键canvas.bind_all("<KeyPress-t>",echo_event)canvas.bind_all("<KeyPress-Left>",echo_event)#⿏标事件canvas.bind_all("<Double-Button-1>",echo_event)canvas.bind_all("<Button-1>",echo_event)canvas.bind_all("<Button-2>",echo_event)canvas.bind_all("<Button-3>",echo_event)以上这篇python对绑定事件的⿏标、按键的判断实例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

如何通过pynput与日志记录实现键盘、鼠标的监听行为？

如何通过pynput与日志记录实现键盘、鼠标的监听行为？
此项功能的实现主要是使用了多线程、键盘/鼠标事件监听，最后通过NLTK语言的处理，从而反向推出电脑的操作记录等信息。

业务逻辑并不复杂，我们一起来看看吧！
安装相关的第三方库，一是关于监听的处理、二是关于日志的记录模块、三是关于简单的线程处理模块。

1、安装pynput库监控键盘、鼠标事件
2、安装日志处理
将相关的模块导入到代码块中。

将目标日志记录文件加入到logger代码处理器中。

编写鼠标被按下时的处理函数。

编写鼠标抬起时的处理函数。

编写鼠标单击、右击以及滑轮的处理函数。

将键盘相关的处理函数加入到键盘事件的监听中。

将鼠标相关的处理函数加入到鼠标事件的监听中。

在main()的处理函数中将鼠标监听、键盘监听分别作为两个线程启动。

最后可以得到一份键盘、鼠标历史执行状态记录的日志文件，通过NLTK语言的处理从而逆向推出电脑的操作内容，这一部分就不演示了。

pydbg hook例子

pydbg hook例子Pydbg是一个用于Windows应用程序调试的Python扩展库。

它提供了一些强大的功能，如追踪程序执行、监视和修改内存、处理异常等。

在本文中，我将为您介绍一些有关Pydbg hook的例子。

1. Hook进程的加载函数在Windows应用程序中，当一个进程加载时，系统会调用一个特定的函数。

我们可以使用Pydbg hook来监视并记录进程的加载情况。

以下是一个示例代码：```pythonimport pydbgimport sysdef load_dll_handler(dbg, args):dll_path = dbg.read_process_memory(args[1], 256)print("Loaded DLL:", dll_path.decode())def main():dbg = pydbg.pydbg()dbg.set_callback(pydbg.defines.LOAD_DLL_DEBUG_EVENT, load_dll_handler)dbg.load("target.exe")if __name__ == "__main__":main()```在这个例子中，我们使用了Pydbg的`set_callback`函数来设置一个回调函数，当目标进程加载DLL时，会调用`load_dll_handler`函数。

在`load_dll_handler`中，我们读取并打印加载的DLL路径。

2. Hook进程的API函数在Windows应用程序中，API函数是非常常见的一种操作。

我们可以使用Pydbg hook来监视并记录进程中调用的API函数。

以下是一个示例代码：```pythonimport pydbgimport pydbg.definesdef api_hook(dbg, args):# 获取API函数的名称api_name = dbg.get_func_name(args[0])print("API Called:", api_name)def main():dbg = pydbg.pydbg()# 设置对所有API函数的监视for func in pydbg.defines.defines:dbg.func_resolve(func)dbg.set_callback(func, api_hook)dbg.load("target.exe")if __name__ == "__main__":main()```在这个例子中，我们使用了Pydbg的`func_resolve`函数来获取API函数的地址，并使用`set_callback`函数来设置一个回调函数，当目标进程调用API函数时，会调用`api_hook`函数。