精华内容
下载资源
问答
  • 实现过程: 使用C语言调用windows的api,来实现对于电脑鼠标和某些键盘的捕获,和模拟鼠标或者按键的...最后将功能打包生成动态链接库供Python调用。在这里我们用到了Python的ctypes库来调用C语言的动态链接文件。 ...

    #实现思路:
    使用C语言调用windows的api,来实现对于电脑鼠标和某些键盘的记录,和模拟鼠标或者按键的按下弹起,而后将函数打包生成动态链接库供Python调用。Python在调用过程中使用到了ctypes库。最后因为C语言部分进行过多次调整而Python部分因为用不到这个东西就一直没有重写因此有些部分很混乱。
    #代码部分:
    #C语言部分:
    1)模拟键盘操作:
    此部分我们实现了模拟键盘的按下,弹起,按下弹起的操作

    DLLIMPORT void K_du(int Jz)
    {
    	keybd_event(Jz,0,0,0);
    	keybd_event(Jz,0,KEYEVENTF_KEYUP,0);
    }
    DLLIMPORT void K_d(int Jz)
    {
    	keybd_event(Jz,0,0,0);	
    }
    DLLIMPORT void K_u(int Jz)
    {
    	keybd_event(Jz,0,KEYEVENTF_KEYUP,0);
    }
    

    keybd_event()函数为windows api在手册中可以查询到具体使用的方法。
    2)模拟鼠标操作:

    DLLIMPORT void M_movej(x,y)
    //移动鼠标到绝对位置 
    {
    	SetCursorPos(x,y);
    }
    
    DLLIMPORT void M_movex(x,y)
    //移动鼠标到相对位置 
    {
    	mouse_event(MOUSEEVENTF_MOVE,x,y,0,0);
    }
    
    DLLIMPORT void M_lu(x,y)
    //模拟鼠标左键弹起 
    {
    	mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
    }
    
    DLLIMPORT void M_ld(x,y)
    //模拟鼠标左键按下 
    {
    	mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);	
    }
    
    DLLIMPORT void M_ru(x,y)
    //模拟鼠标右键弹起 
    {
    	mouse_event(MOUSEEVENT_RIGHTUP,0,0,0,0);
    }
    
    DLLIMPORT void M_rd(x,y)
    //模拟鼠标右键按下 
    {
    	mouse_event(MOUSEEVENT_RIGHTDOWN,0,0,0,0);
    }
    
    DLLIMPORT void M_mu(x,y)
    //模拟鼠标中键弹起 
    {
    	mouse_event(MOUSEEVENT_MIDDLEUP,0,0,0,0);
    }
    
    DLLIMPORT void M_md(x,y)
    //模拟鼠标中键落下 
    {
    	mouse_event(MOUSEEVENT_MIDDLEOWN,0,0,0,0);
    }
    
    DLLIMPORT void M_ms()
    {
    	mouse_event(MOUSEEVENTF_WHEEL, 0,0,1,NULL);
    	//此部分上下两个部分都可以实现模拟鼠标滑轮的操作任选其一
    	POINT Mouse_xy;
    	GetCursorPos(&Mouse_xy);
    	HWND mainWindow=WindowFromPoint(Mouse_xy);
    	SendMessage(mainWindow,WM_MOUSEWHEEL,WHEEL_DELTA<<16,0);
    }
    
    DLLIMPORT void M_mx()
    {
    	mouse_event(MOUSEEVENTF_WHEEL, 0,0,-1,NULL);
    	//此部分上下两个部分都可以实现模拟鼠标滑轮的操作任选其一
    	POINT Mouse_xy;
    	GetCursorPos(&Mouse_xy);
    	HWND mainWindow=WindowFromPoint(Mouse_xy);
    	SendMessage(mainWindow,WM_MOUSEWHEEL,-WHEEL_DELTA<<16,0);
    }
    
    
    DLLIMPORT long G_mousex()//获得鼠标位置的横坐标
    {
    	long x,y;
    	POINT mxy;
    	GetCursorPos(&mxy);
    	x=mxy.x;
    	//y=mxy.y;
    	return x;
    }
    
    DLLIMPORT long G_mousey()//获得鼠标位置的纵坐标
    {
    	long x,y;
    	POINT mxy;
    	GetCursorPos(&mxy);
    	//x=mxy.x;
    	y=mxy.y;
    	return y;
    }
    
    

    3)判断操作:

    DLLIMPORT int J_board(int boardcode)//boardcode是相应按键的键值
    {
    	int T;
    	
    	T=GetKeyState(boardcode);/*GetKeyState()函数可以判断按键的状态,返回四个参数0,1,-127,-128分别代表相应按键的按下或者弹起*/
    	if(T==0||T==1)
    	{
    		return 0; 
    		}	
    	else if(T==-127||T==-128)
    	{
    		return 1; 
    	} 
    }
    

    以上函数最后均生成了dll动态链接库。因此函数名之前多了一个DLLIMPORT
    #python部分

    Base

    #2020/12/4
    '''
       加入了Judge类判断鼠标左键和NumLock键按下弹起
    
    '''
    
    import ctypes
    R=ctypes.WinDLL(".\DLL\Remove_m.dll")
    K=ctypes.WinDLL(".\DLL\Keyboard.dll")
    M=ctypes.WinDLL(".\DLL\Mouse.dll")
    C=ctypes.WinDLL(".\DLL\Ctrl.dll")
    J=ctypes.WinDLL(".\DLL\J_MouseR.dll")
    N=ctypes.WinDLL(".\DLL\J_numlock.dll")
    Ct=ctypes.WinDLL(".\DLL\J_ctrl.dll")
    class Mouse:
       def rdu(self):
          M.Mr_du()
       def ld(self):
          M.Ml_d()
       def lu(self):
          M.Ml_u()
       def remove(self,x,y):
          '''在x,y方向上移动距离'''
          if x>=0:
             for i in range(x):
                M.I_mouse(0,0,1,0,0)
          elif x<0:
             for i in range(-x):
                M.I_mouse(0,0,0,1,0)
          if y>=0:
             for i in range(y):
                M.I_mouse(1,0,0,0,0)
          elif y<0:
             for i in range(-y):
                M.I_mouse(0,1,0,0,0)
       def flash(self,x,y):
          '''移动到x,y坐标位置'''
          R.Remove_m(x,y)
       def get_x(self):
          return M.Gmouse_x()
       def get_y(self):
          return M.Gmouse_y()
    
    class Keyboard:
       def kud(self,jz):
          K.Keyboard_ud(jz)
       def ku(self,jz):
          K.Keyboard_u(jz)
       def kd(self,jz):
          K.Keyboard_d(jz)
    
    class Txt:
       def copy(self,Str):
          C.Ctrl_C(bytes(Str,encoding="gbk"))
          
    class Judge:
       def judge_mr(self):
          return J.J_Mr()
       def judge_numlock(self):
          return N.J_numlock()
       def judge_ctrl(self):
          return Ct.J_ctrl()
    
    

    datachange

    def datachange(filename):
       f=open(filename+".txt","r")
       line=f.readline()
       otxtline=[]
       while line:
          otxtline.append(line)
          line=f.readline()
       f.close()
       f=open(filename+"copy"+".txt","a")
       for i in range(len(otxtline)-3):
          str1=otxtline[i]
          str2=otxtline[i+1]
          str3=otxtline[i+2]
          if str2[12]=="0":
             if str1[12]=="1":
                f.write(str2)
          elif str2[12]=="1":
             if str1[12]=="0" or str3[12]=="0":
                f.write(str2)
       f.close()
    

    delete

    import ctypes
    G=ctypes.WinDLL(".\DLL\Gmouse.dll")
    def Getmousepos():      
       print('x坐标:'+str(G.Gmouse_x()))
       print('y坐标:'+str(G.Gmouse_y()))
    

    main

    #2020/12/6
    #0.2版本
    #2020/12/7
    #导入read03模块,读取文件夹中脚本文件和记录文件
    #改进delete命令
    import delete
    import Memory
    import R_main
    import script
    import Getmousepos
    import read03
    import datachange
    while True:
       order=input("命令:")
       if order=="delete":
          filetype=input("文件类型:")
          delete.delete(filetype)
       elif order=="script":
          filename=input("文件名:")
          print("脚本正在生成")
          script.script(filename)
          print("脚本已经生成")
       elif order=="write":
          x=int(input("输入x坐标:"))
          y=int(input("输入y坐标:"))
          filename=input("输入预文件名:")
          R_main.R_main(filename+".txt",x,y)
       elif order=="memory":
          filename=input("文件名称:")
          Memory.memory(filename+".txt")
       elif order=="mousexy":
          Getmousepos.Getmousepos()
       elif order=="exec":
          S1=input("输入代码:")
          S2=input("输入代码:")
          exec(S1+'\n'+S2)
       elif order=="readall":
          read03.read_all()
       elif order=="data":
          filename=input("输入文件名:")
          datachange.datachange(filename)
       else:
          print("指令不存在!")
    
    

    Memory

    #2020/12/5
    #模块名:Memory
    #记录鼠标的活动生成记录文件
    
    import Base
    import time
    M=Base.Mouse()
    J=Base.Judge()
    
    def memory(filename):
       file=open(filename,'a')
       while True:
          if J.judge_numlock()==1:
             break
          else:
             if J.judge_ctrl()==1:
                time.sleep(0.02)
                file.write(time.strftime("%H:%M:%S",time.localtime())+" 状态:"+str(J.judge_mr())+" 位置坐标:"+'('+str(M.get_x())+','+str(M.get_y())+')'+'c'+'\n')
             else:
                time.sleep(0.02)
                file.write(time.strftime("%H:%M:%S",time.localtime())+" 状态:"+str(J.judge_mr())+" 位置坐标:"+'('+str(M.get_x())+','+str(M.get_y())+')'+'\n')
       file.close()
    
    

    R_main

    #2020/12/5
    #2020/12/8
    #加入r_main()特定输入
    #模块名:R_main
    #将名为filename的文件逐行读取并且放入剪切板里面
    
    import Base
    import random
    
    def OutPut(Str,M_x,M_y):
       C=Base.Txt()
       K=Base.Keyboard()
       M=Base.Mouse()
       C.copy(Str)
       M.flash(M_x,M_y)
       M.ld()
       M.lu()
       K.kd(17)
       K.kud(86)
       K.ku(17)
    #这个函数实现鼠标移动到某个位置然后单击后输入剪切板内的内容
    
    def InPut(filename):
       file=open(filename)
       line=file.readline()
       filetxt=[]
       while line:
          filetxt.append(line)
          line=file.readline()
       file.close()
       return filetxt
    #将txt文件中的内容赋值到列表里面
    
    def R_main(filename,x,y):
       Str=InPut(filename)[random.randint(0,len(InPut(filename))-1)]
       OutPut(Str,x,y)
    def r_main(filename,x,y,i):
       Str=InPut(filename)[i]
       OutPut(Str,x,y)
    
    

    read03

    #2020/12/5
    #2020/12/8
    #加入r_main()特定输入
    #模块名:R_main
    #将名为filename的文件逐行读取并且放入剪切板里面
    
    import Base
    import random
    
    def OutPut(Str,M_x,M_y):
       C=Base.Txt()
       K=Base.Keyboard()
       M=Base.Mouse()
       C.copy(Str)
       M.flash(M_x,M_y)
       M.ld()
       M.lu()
       K.kd(17)
       K.kud(86)
       K.ku(17)
    #这个函数实现鼠标移动到某个位置然后单击后输入剪切板内的内容
    
    def InPut(filename):
       file=open(filename)
       line=file.readline()
       filetxt=[]
       while line:
          filetxt.append(line)
          line=file.readline()
       file.close()
       return filetxt
    #将txt文件中的内容赋值到列表里面
    
    def R_main(filename,x,y):
       Str=InPut(filename)[random.randint(0,len(InPut(filename))-1)]
       OutPut(Str,x,y)
    def r_main(filename,x,y,i):
       Str=InPut(filename)[i]
       OutPut(Str,x,y)
    

    script

    #2020/12/5
    #模块名:script
    #读取记录文件生成脚本文件
    import time
    #这个部分将记录文件读出来
    def script(filename):
       file=open(filename+".txt",'r')
       line=file.readline()
       Fileline=[]
       while line:
          Fileline.append(line)
          line=file.readline()
       file.close()
       #-----------------------#
       f=open("S_cript.py","a")
       #这个部分写入脚本的头文件
       f.write("import Base\n")
       f.write("import time\n")
       f.write("import R_main\n")
       f.write("M=Base.Mouse()\n")
       f.write("K=Base.Keyboard()\n")
       f.write("def script():\n")
       #-----------------------#
       for i in range(len(Fileline)):
          Str=Fileline[i]
          StrState=Str[12]
          StrCtrl=Str[-2]
          for x in range(len(Str)):
             if Str[x]=="(":
                start=x
             if Str[x]==",":
                end=x
             if Str[x]==")":
                end_t=x
          Str_x=Str[start+1:end]
          Str_y=Str[end+1:end_t]
          f.write("\tM.flash"+"("+str(Str_x)+","+str(Str_y)+")"+"\n")
          if StrState=="0":
             f.write("\tM.lu()\n")
          elif StrState=="1":
             f.write("\tM.ld()\n")
          if StrCtrl=="c":
             f.write("\tR_main.R_main("+"\"预文件.txt\""+","+str(Str_x)+","+str(Str_y)+')\n')
          f.write("\ttime.sleep"+"("+"0.02"+")"+"\n")
       f.close()
    
    
    #for i in range(len(Fileline)):
    #   print(Fileline[i])
    
    
    

    python部分可能比较乱可以通过main来进行梳理。
    抱拳了老铁。

    展开全文
  • 调用大漠插件。 C:\Windows\SysWOW64 regsvr32 dm.dll 注册完成 然后是python-32位,如果使用pycharm一定要选好解释器,如果还用了ipython等工具,一定要把默认解释器也相应修改。 当然最简单的就是在visual code上...

    我们准备在python中调用按键精灵的大漠插件来完成模拟驱动的鼠标键盘操作。大漠 综合 插件 (dm.dll)采用vc6.0编写,识别速度超级快! 采用COM接口编写,适用于所有语言调用。
    网上相关教程极少,我们只能一步步自己摸索。
    首先下载大漠核心组件dm.dll,在win10的新版总是出现闪退bug,为了稳定性,选择比较老的3.2xxx版本了。
    下载地址
    下载解压后,将dm.dll复制到C:\Windows\SysWOW64文件夹里。(显然你应该是64位系统,应该没人用32位了吧)
    以管理员方式打开cmd,如果你是windows管理员账号直接打开应该就没问题了
    键入:

    C:
    cd C:\Windows\SysWOW64
    regsvr32 dm.dll
    

    大功告成了,注册完成

    import win32com.client
    
    
    dm = win32com.client.Dispatch('dm.dmsoft')  #调用大漠插件
    dm.moveto(10,10)
    

    其中win32com帮我们加载了dll文件,直接调用dm.function dm.constant就可以使用插件了,注意有返回值的对象最好写上等于符号,哪怕他返回的变量没有用(vc的语法)

    然后运行,发现一长串的报错…
    别急,分析报错,我们的python版本一般来说我64位的,而大漠是02年推出的脚本插件,是基于按键精灵和vc语言开发的Active X脚本,它只支持32位。

    为了支持插件我们只好下载一个32位的python下载地址
    我下载的是python3.6-32的
    下载之后最好把add path勾选,然后把之前64位的path再系统变量里取消掉,之后再讲为什么要这么做。之后呢,如果使用pycharm一定要选好解释器(32位),如果还用了ipython等工具,一定要把默认解释器也相应修改。

    当然最简单的就是在visual code加上Ipython模块上编辑啦,你直接替换一下解释器属性就行了。

    如果以上配置成功,再运行以上代码。你的输出大概这样,然后鼠标会移到屏幕左上角。

    输出正确

    仔细阅读插件文档加调试了一两天之后…
    彻底放弃了long SetSimMode(mode)这个函数,这个函数总是返回值为0,提示我未注册,导致我没法进入硬件驱动模式,从而被楚留香屏蔽了脚本输入。

    直到今天再读文档发现了这个函数
    头秃
    于是修改代码为如下,保存名字为 test.py
    注:这段代码是不可以直接运行的,因为大漠插件要求管理员权限,直接run可能运行失败
    运行方法:
    1.首先将python3.6-32位的path加入系统变量Path中
    2.以管理员身份启动命令行
    3.键入 python X:\xxxx(你的路径)\test.py
    如果你没添加path,要么去修改path,要么直接cd到python3.6-32位目录下输入该指令

    import win32com.client
    import win32con
    import win32gui
    import time
    hwnd=win32gui.FindWindow(None,'楚留香')
    if(win32gui.IsIconic(hwnd)):
        win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
    win32gui.SetWindowPos(hwnd, win32con.HWND_TOPMOST, 300,200,1200,800,win32con.SWP_SHOWWINDOW)
    dm = win32com.client.Dispatch('dm.dmsoft')  #调用大漠插件
    re=dm.BindWindow(hwnd,"normal","dx2","dx",4)
    print(re)
    print(dm.GetLastError())
    def keydownup(num,times):
        while True:
            dm_res=dm.keypress(num)
            time.sleep(times)
    keydownup(27,3)
    

    如果打印值不为1、0,说明配置是有问题
    可能导致问题几点:
    1.关闭uca,拿win10来说控制面板-安全和维护-关闭所有防火墙-更改用户控制和账户控制设置,拉到最低
    1

    2.重启开机按F1,F2和DEL,进入BIOS模式,进入ROOT或者Security选项卡,把Secure Boot 选项的enabled 改为disable
    2
    3.将游戏同时也以管理员身份启动

    这段代码是每隔3s给楚留香发送1个ESC键,如果这个ESC没被屏蔽掉,证明我们模拟输入就成功了。
    测试成功

    然后游戏中显然ESC键生效了,我们已经基本掌握了如何用python+大漠插件方式向“楚留香”发送模拟指令,接下来的逻辑工作无非是确定每个点的坐标,然后进行键位组合即可。

    但是还有一个问题没解决,就是如何识别文字。
    摆摊界面的价格,机器是不可能自动识别的,我们必须识别出来再与我们理想价格做一个比较,才能辅助我们抢不抢购。

    附录:大漠插件虚拟键码
    key_str 虚拟键码

    "1",          49
    
    "2",          50
    
    "3",          51
    
    "4",          52
    
    "5",          53
    
    "6",          54
    
    "7",          55
    
    "8",          56
    
    "9",          57
    
    "0",          48
    
    "-",          189
    
    "=",          187
    
    "back",       8
    
     
    
    "a",          65
    
    "b",          66
    
    "c",          67
    
    "d",          68
    
    "e",          69
    
    "f",          70
    
    "g",          71
    
    "h",          72
    
    "i",          73
    
    "j",          74
    
    "k",          75
    
    "l",          76
    
    "m",          77
    
    "n",          78
    
    "o",          79
    
    "p",          80
    
    "q",          81
    
    "r",          82
    
    "s",          83
    
    "t",          84
    
    "u",          85
    
    "v",          86
    
    "w",          87
    
    "x",          88
    
    "y",          89
    
    "z",          90
    
     
    
    "ctrl",       17
    
    "alt",        18
    
    "shift",      16
    
    "win",        91
    
    "space",      32
    
    "cap",        20
    
    "tab",        9
    
    "~",          192
    
    "esc",        27
    
    "enter",      13
    
     
    
    "up",         38
    
    "down",       40
    
    "left",       37
    
    "right",      39
    
     
    
    "option",     93
    
     
    
    "print",      44
    
    "delete",     46
    
    "home",       36
    
    "end",        35
    
    "pgup",       33
    
    "pgdn",       34
    
     
    
    "f1",         112
    
    "f2",         113
    
    "f3",         114
    
    "f4",         115
    
    "f5",         116
    
    "f6",         117
    
    "f7",         118
    
    "f8",         119
    
    "f9",         120
    
    "f10",        121
    
    "f11",        122
    
    "f12",        123
    
     
    
    "[",          219
    
    "]",          221
    
    "\\",         220
    
    ";",          186
    
    "'",          222
    
    ",",          188
    
    ".",          190
    
    "/",          191
    
    展开全文
  • #Python下在windows系统下仿照按键精灵 功能:找到对应软件程序,并对界面进行操作,主要进行点击、信息输入、输出信息得检测 ##所用到得库 库名 作用 win32gui gui调用 win32api 调用wins功能接口 win...

    #Python下在windows系统下仿照按键精灵
    功能:找到对应软件程序,并对界面进行操作,主要进行点击、信息输入、输出信息得检测
    ##所用到得库

    库名 作用
    win32gui gui调用
    win32api 调用wins功能接口
    win32con,win32ui 获取wins窗口界面
    win32clipboard 操作wins下得粘贴板

    ##封装所要用到得函数(自定义)

    自定义函数名 功能
    create_translate_table 生成键盘上数字和对应得键码
    find_process_window 根据窗口标题查找对应窗口
    fix_window 确保应用进程窗口总显示最前面
    judge_process_run_state 判断应用进程运行状态
    mouse_event 定义鼠标事件
    clear_input 清空输入框
    select_all 模拟Ctrl+a
    copy_all 模拟Ctrl+c
    pasue_all 模拟Ctrl+v
    get_clipboard_text 获取windows下粘贴板得内容
    click_process 点击界面
    input_text_for_process 进程界面输入数据

    下面数字键和对应键码

    键码
    0 48
    1 49
    2 50
    3 51
    4 52
    5 53
    6 54
    7 55
    8 56
    9 57

    #各个函数代码及解说

    
    titles = set()
    process_window_title=U"软件窗口标题"
    translate_dict={}
    
    def create_translate_table():
        """生成键盘上数字和对应的键码:键值:键码"""
        
        for i in range(48,58):
            translate_dict[chr(i)]=i
        translate_dict["\."]=110
    
    def find_process_window():
        """根据窗口进行查process界面,并返回句柄以及左上角坐标left up;右下角坐标right,bottom"""
    
        win = win32gui.FindWindow(None, process_window_title)
        win32gui.ShowWindow(win, win32con.SW_SHOWNORMAL)#将窗口显示到屏幕
        time.sleep(3)
        # 获取窗口左上角和右下角坐标
        (left, up, right, bottom) = win32gui.GetWindowRect(win)
        return win,left, up,right, bottom
    
    def foo(hwnd,mouse):
        """查找打开的所有窗口"""
        
        if IsWindow(hwnd) and IsWindowEnabled(hwnd) and IsWindowVisible(hwnd):
            titles.add(GetWindowText(hwnd))
    
    def judge_process_run_state():
        """判断是否已经打开软件窗口,打开返回True,未打开返回False"""
    
        EnumWindows(foo, 0)
        lt = [t.decode("GBK") for t in titles if t]
        lt.sort()
        if process_window_title in lt:
            return True
        else:
            return False
    def fix_window(win,left,up):
        """确保软件窗口总显示在最前"""
        
        hWndList = []
        titlelist=[]
        win32gui.EnumWindows(lambda hWnd, param: param.append(hWnd), hWndList)#获取所有窗口句柄
        for hwd in hWndList:
            title=win32gui.GetWindowText(hwd)#返回各个窗口的标题
            if title == '':
                continue
            else:
                titlelist.append(title)#将非空标题的窗口标题组成一个列表
        if (titlelist.index(process_window_title.decode("utf-8").encode("GBK")) >= 2):  #若是process标题索引不为0,表明process窗口不在最前面
            win32gui.SetWindowPos(win, win32con.HWND_TOPMOST, left, up, 1300, 760, win32con.SWP_SHOWWINDOW)# 将应用窗口显示到最前面
    
    def mouse_event(left,up,x,y):
        """定义鼠标事件"""
        int_x=int(x)
        int_y=int(y)
        win32api.SetCursorPos((left + int_x, up + int_y))
        win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP | win32con.MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
        time.sleep(2)
    
    
    def clear_input(times):
        """通过backspace删除输入框的内容,且需要指定删除次数"""
        for i in range(times):
            win32api.keybd_event(8, 0, 0, 0)
            win32api.keybd_event(8, 0, win32con.KEYEVENTF_KEYUP, 0)
            time.sleep(0.1)
    
    def input_text(input_num):
        """进行界面数据输入"""
        
        create_translate_table()
        for i in str(input_num):
            if i == ".":
                ma=110
            else:
                ma=translate_dict[i]
            win32api.keybd_event(ma,0,0,0)
            win32api.keybd_event(ma,0,win32con.KEYEVENTF_KEYUP,0)
            time.sleep(0.1)
    
    def select_all():
        """实现crtl+a,注意keyup键盘的顺序,不然会概率出现失效"""
        win32api.keybd_event(17,0,0,0)
        win32api.keybd_event(65,0,0,0)
        win32api.keybd_event(65, 0, win32con.KEYEVENTF_KEYUP, 0)
        win32api.keybd_event(17, 0, win32con.KEYEVENTF_KEYUP, 0)
        time.sleep(0.1)
    
    
    def copy_all():
        """实现crtl+c,注意keyup键盘的顺序,不然会概率出现失效"""
    
        w.OpenClipboard()
        w.EmptyClipboard()
        w.CloseClipboard()
        win32api.keybd_event(17,0,0,0)
        win32api.keybd_event(67,0,0,0)
        win32api.keybd_event(67, 0, win32con.KEYEVENTF_KEYUP, 0)
        win32api.keybd_event(17, 0, win32con.KEYEVENTF_KEYUP, 0)
        time.sleep(0.1)
    
    
    def pasue_all():
        """实现crtl+v,注意keyup键盘的顺序,不然会概率出现失效"""
    
        win32api.keybd_event(17,0,0,0)
        win32api.keybd_event(86,0,0,0)
        win32api.keybd_event(86, 0, win32con.KEYEVENTF_KEYUP, 0)
        win32api.keybd_event(17, 0, win32con.KEYEVENTF_KEYUP, 0)
        time.sleep(0.1)
    
    def get_clipboard_text():
        """获取windows下粘贴板的内容--PS需要选择unicodetext格式,不然会出现乱码"""
        w.OpenClipboard()
        t=w.GetClipboardData(win32con.CF_UNICODETEXT) #一定要选unicode数据类型,不然会出现乱码
        w.CloseClipboard()
        return t
    
    def click_process(left,up,x,y):
        """点击process界面"""
        int_x=int(x)
        int_y=int(y)
        mouse_event(left,up,int_x,int_y)
    
    def input_text_for_process(left,up,x,y,input_text):
        """对process输入框,先清除然后再进行数据输入"""
        int_x=int(x)
        int_y=int(y)
        mouse_event(left,up,int_x,int_y)
        clear_input(12)
        input_text(input_text)
    

    总结
    大家根据各自所需,对函数进行自由搭配从而实现自己所需要的功能

    展开全文
  • 1.导入依赖模块 import win32gui,win32api,win32con 2.获取当前鼠标位置 a = win32api.GetCursorPos() ...调用移动函数 mouse_move(1000,300) time.sleep(3) a = win32api.GetCursorPos() print(a

     

    实现鼠标移动

    1.导入依赖模块

    import win32gui,win32api,win32con

    2.获取当前鼠标位置

    a = win32api.GetCursorPos()
    print(a)

    3.将鼠标移动到指定位置

    定义移动函数:

    def mouse_move(x,y):
        win32api.SetCursorPos([x,y])
    

    调用移动函数

    mouse_move(1000,300)
    time.sleep(3)
    a = win32api.GetCursorPos()
    print(a)
    
    mouse_move(1300,300)
    time.sleep(3)
    b=win32api.GetCursorPos()
    print(b)
    
    mouse_move(599,800)
    time.sleep(3)
    c=win32api.GetCursorPos()
    print(c)

    交互输出结果:

    移动鼠标输出

     

    实现录制路径

    import win32gui,win32api,win32con
    import time as tm
    import time
    import os
    import cv2
    import numpy as np
    import time
    import win32gui,win32con
    import sys
    import time
    from pynput import mouse
    import datetime
    
    f= open("log.txt","w+")
    f = open('C:\\Users\\Administrator\\Desktop\\open.txt','w') ## 先打开要输出的文件
    
    sys.stdout = f ## 重定向到f文件
    # 鼠标移动事件
    def on_move(x, y):
        print('[Move]')
    
    
    
    time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
    
    # 鼠标点击事件
    def on_click(x, y, button, pressed):
        print(time,'[Click]', (x, y, button.name, pressed))
    
    
    # 鼠标滚动事件
    def on_scroll(x, y, x_axis, y_axis):
        print(time,'[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()

     

    展开全文
  • 1.第一个文件,trial.py,python代码调用PyAutoGUI操作鼠标键盘。可以通过修改start_time和end_time来确定程序自动开始和结束的时间(24小时制)。import pyautogui as agimport datetimeimport randomimport time...
  • Python调用办法: #coding=utf-8 import requests,sys if sys.getdefaultencoding() != 'utf-8':  reload(sys)  sys.setdefaultencoding('utf-8') r = requests.get('http://www.freeyuming.cn/word') ...
  • 好像很多人是从学习按键精灵开始入门编程的,然而你不可能在简历上写精通按键精灵吧。在大数据,人工智能流行的今天,Python红的发紫,你可以知道Python有一个神奇的库叫pyautogui, 可以操作键盘和鼠标。 首先我们用...
  • python调用dm.dll

    千次阅读 2019-01-06 16:39:38
    之前是学按键精灵入门的编程,对于python也没系统化的学习过。学习python以来,自己写了一个在公司用的工具,也不怎么好。但是好歹是第一个作品,实现了在公司上班中经常使用的一些功能。今天突发奇想,能不是用...
  • 这是一个压缩文件,里面包含了最后一版免费大漠插件(3.11版),以及接口说明,大漠综合工具,大漠后台绑定测试工具,windows注册大漠插件,易语言,按键精灵python3调用大漠插件文本教程,python3调用易语言编译的...
  • 好了, 这里隆重介绍下pywinauto, 它是一个基于win32 api的库,我们可以用它实现对windows窗口程序的调用。 首先我们可以用它启动一个程序. 运行后就会启动记事本。接下来我们想输入一些字符在记事本中,这里就有个...
  • 识别验证码一直是本人想要做的事情,一直在接触按键精灵,了解到有一个虹鱼图灵识别插件专门做验证码和图像识别,原理就是图片处理和制作字库识别,制作字库我一直觉得很麻烦,工程量太大。不管怎样,它能用能达到我...
  • 原创文章,欢迎转载。转载请注明:转载自 祥的博客 原文链接: 文章目录@[toc]动机原理代码使用方法声明&...其实就相当于一个按键精灵,用Python调用adb工具去模拟手指点击,退出事件,没什么科技含量,只是对a...
  • 在小编学习python中的模拟点击之前,我们想要对...直接用python调用,获取特定点位置上的颜色,非白色就发送点击指令。然后循环等待下一个黑色块的到来。同时设定定时时间,若长时间依旧是这个颜色,证明游戏结束,直接
  • 完整封装了大漠插件3.11可用的部分功能指令,并且附件包自带了调用大漠需要的python环境以及打包exe文件所需环境配置教程...下载本附件后,可以完爆易语言和按键精灵的基于大漠插件的功能,因为这种操作是很新式的操作
  • 触动精灵使用lua实现对手机的自动化操作, 比按键精灵好用, 现在有个小需求就是对手机截屏后将图片通过post方式提交到服务器端. lua代码 python用习惯了, 再写lua的代码总感觉有点别扭, 有些语法还得再翻翻文档,这里...
  • 如果为此专门下载一个按键精灵,总感觉杀鸡用牛刀,所以就开始探索一些轻量级解决方案。本人电脑上配置了Python,自然就想到那句名言 方案 参考网上的各种例子后,发现了PyUserInput这个项目。在配置完成后,调用...
  • 今天讲讲怎么自动化实现快速点击加速增加我们的鲤鱼跃龙门的体验金额,实现的方法有几种:按键精灵(和谐)、appuim(环境搭建复杂)、adb(推荐)。   adb是电脑驱动安卓手机的接口驱动,我们是利用在Python...
  • 0407

    2017-04-07 17:37:29
    Python实现windows下模拟按键和鼠标点击的方法Python&按键精灵自动化 如何利用Python和win32编程避免重复性体力劳动(一)——开始、FindWindow和FindWindowEx按键精灵怎么调用公开的DLL接口函数??
  • 最近产线有个需求就是稳定烧录,减少人工,一开始用了按键精灵但是发现uniflash的反应时间不稳定所以想用批处理文件来实现 在C:\ti\ccsv8\ccs_base\scripting\examples\uniflash\cmdLine,只要安装ccs8就会有这个...
  • py大漠3.11完整环境版

    2019-04-16 14:03:09
    完整封装了大漠插件3.11可用的部分功能指令,并且附件包自带了调用大漠需要的python环境以及打包exe文件所需环境配置教程...下载本附件后,可以完爆易语言和按键精灵的基于大漠插件的功能,因为这种操作是很新式的操作
  • 自动化测试的惊喜

    千次阅读 2019-12-10 10:23:01
    多多少少,接触了selenium,appium这些控制浏览器,手机app的python框架,然后我一开始会的按键精灵,易语言写游戏模拟辅助,自动任务那些,才明白,这些操作在行业里有个好听的名字-自动化测试 然后,我一直在寻找...
  • airtest踩坑日记

    2021-03-29 00:08:20
    终于可以摆脱按键精灵的束缚了,结果好家伙,这个玩意就是网易开发的bug集,全是bug,一步一步踩坑过来的,以下为记录的bug以及应对方法:(PS:移动原生的测试人员建议直接用poco吧,坑太多,不建议踩,而且它也是...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
关键字:

python调用按键精灵

python 订阅