• python写的 自定义连点器 的开发全过程（抢票、信息轰炸等、游戏连招等）——思路及解析【内附完整源码】

    前些天留意到我妈一直在预约四价疫苗都约不上，就想着写个程序来模拟人的操作去点击，判断疫苗是否被抢完，无限循环去刷新这个页面，一旦疫苗可预约就立马抢下来选择时间接种人。当预约成功后就语音循环播报：已经抢到，赶紧过来看一下。

    基于以上的想法和需求，我花了半小时编辑了以下代码，并在一小时内成功预约。

    1. import pyautogui
    2. from ctypes import *  # 获取屏幕上某个坐标的颜色
    3. from time import sleep
    4. import time
    5.  
    6. start = time.time()
    7. def get_color(x, y):
    8.     gdi32 = windll.gdi32
    9.     user32 = windll.user32
    10.     hdc = user32.GetDC(None)  # 获取颜色值
    11.     pixel = gdi32.GetPixel(hdc, x, y)  # 提取RGB值
    12.     r = pixel & 0x0000ff
    13.     g = (pixel & 0x00ff00) >> 8
    14.     b = pixel >> 16
    15.     return [r, g, b]
    16. print(get_color(297,454))
    17. while True:
    18.     if get_color(240 , 255) == [60,211,180] or get_color(247,255) == [60,211,180] or get_color(253,255) == [60,211,180] or get_color(260,255) == [60,211,180] or get_color(270,255) == [60,211,180] or get_color(280,255) == [60,211,180] or get_color(290 ,255) == [60,211,180] or get_color(300 ,255) == [60,211,180] or get_color(310,255) == [60,211,180] or get_color(320, 255) == [60,211,180]:
    19.         pyautogui.click(310,255)#点进去抢
    20.         sleep(0.5)
    21.         pyautogui.click(467,262)#选择预约时间
    22.         while True:
    23.             if get_color(297,454) == [0,142,255]:
    24.                 break
    25.             else:
    26.                 sleep(0.3)
    27.         sleep(0.5)
    28.         pyautogui.click(498,454)#点击下午
    29.         sleep(0.5)
    30.         pyautogui.click(467,520)#选择时间
    31.         sleep(0.5)
    32.         pyautogui.click(470,899)#点选好了
    33.         sleep(0.5)
    34.         pyautogui.click(470, 899)#点立即预约
    35.         #sleep()
    36.         break
    37.     else:
    38.         pyautogui.click(123,60)
    39.         sleep(0.8)#刷新
    40. print('总耗时：'.format(time.time()-start))
    41. print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
    42. while 1:
    43.     import pyttsx3
    44.     engine = pyttsx3.init()
    45.     engine.say('我抢到了!快来看一下')
    46.     engine.runAndWait()
    47.     sleep(1)

    实现思路大致流程图：

    可以看到逻辑非常简单即可实现我想要的功能，不过即使是这样，我也花了差不多半小时的时间来编写代码。于是我就在想，要是以后我要开发抢票、技能连招啊、信息轰炸朋友啊等等的功能，是不是也要这么多时间呢，那我能不能自己造轮子来快速帮助我开发我想要的脚本呢。

    至此，此章的内容正式开始了。

    我将一步一步带着读者来开发这个快速开发自定义连点器的程序（有一点点拗口）

    目录

    整体思路:

    所有功能

    简单演示

    点击功能

     点击功能代码如下：

    执行时的逻辑：

    延时功能

    执行时的逻辑： 

    连点功能

    执行时的逻辑：

    存储功能

    读取功能

    存储导入功能【升级版】

    导入（功能实现）

    导入（逻辑代码）

    存储（功能实现）

    存储（逻辑代码） 

    拖拽功能

    功能实现

    逻辑代码：

    功能实现

     逻辑代码

    右击、中击、双击功能的实现

    功能实现

    逻辑代码

    按键功能

    功能实现

    逻辑代码

    滚动滚轮功能

    功能实现

    逻辑代码

    查看功能

     执行功能

    逻辑判断功能板块

    判断功能

    判断功能的逻辑代码

     逻辑执行功能的实现

    逻辑块存储功能的实现

    逻辑块存储逻辑代码

    逻辑块导入功能的实现

    完整代码

    整体思路:

    一般需要的功能有：点击、延时、连点、拖拽。一般这四个功能就能完成绝大多数的简单的辅助脚本开发了，但我想做得稍微高级一点，功能多一点，就想另外开发：循环、判断、模拟按键、文本输入、存储操作、读取操作的功能。

    那么我们就要朝着我们想要实现的九大功能来开发：循环、点击、延时、连点、拖拽、判断、模拟按键、文本输入、存储操作、读取操作。

    首先就是希望我的每一步操作都会被程序记录下来并执行，我们可以定义一个列表来存储每一个操作，列表中的每一个元素就是每一步的操作，然后遍历这个列表来读取并执行每一个操作就可以将一整个操作全部执行。

    当我的每一步操作都输入完毕后，我都希望程序能自动帮我把程序存储下来方便我下一次使用，这样下次使用就不用再编译多一次了。

    每一个列表的第0项就是需要操作的功能，第0项之后都是各种参数。

    所有功能

    简单演示

      

    点击功能

    要想电脑帮我们点击，首先要告诉电脑我要点击的位置在哪里。想要获取鼠标位置就需要用到pyautogui库，这个库下有个position()方法可以返回鼠标位置的X坐标，Y坐标。

    也可以参考一下我之前的文章：实时获取鼠标位置_晋升阁的博客-CSDN博客_实时显示鼠标坐标

    定义获取位置函数

    1. import pyautogui
    2. def get_xy():
    3.     x, y = pyautogui.position()
    4.     return [x,y]

    用面向对象思想来简化程序，提高代码复用率，使程序可读性更高，是python开发的重要思想之一哦

    pyautogui库还有非常多常见功能，感兴趣的可以翻看我之前写的博客：像selenium一样操作电脑，保姆式教学——速成篇_晋升阁的博客-CSDN博客

     点击功能代码如下

    1. step=[]
    2. while True:
    3.     choose = input('请输入你需要使用的功能：')
    4.     if choose == '点击':
    5.         click = []
    6.         while 1:
    7.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    8.             if click_dongzuo == '1':
    9.                 click_weizhi = get_xy()
    10.                 click.append('点击')
    11.                 click.append(click_weizhi)
    12.                 step.append(click)
    13.                 break
    14.             elif click_dongzuo == '0':
    15.                 print('操作已取消')
    16.                 break
    17.             else:
    18.                 print('请输入正确的操作（输入“0”或“1”')

    执行时的逻辑：

    1.             for i in step1:
    2.                 if i[0] == '点击':
    3.                     x = int(i[1][0])
    4.                     y = int(i[1][1])
    5.                     print(f'{x},{y}')
    6.                     pyautogui.click(x,y)

    记录点击需要记录点击功能、位置参数生成一个列表，然后将列表append到step总列表中去

    延时功能

    使用到了python内置库中的time模块，可以使程序强制停止相应时间。将参数生成列表append到step总列表中去

    1. if choose =='延时':
    2.     while 1:
    3.         timerr = []
    4.         try:
    5.             timex = int(input('请输入延时时间：'))
    6.             timerr.append('延时')
    7.             timerr.append(timex)
    8.             step.append(timerr)
    9.             break
    10.         except:
    11.             print('延时失败/n请输入正确的延时时间')
    12.             continue

    执行时的逻辑： 

    1. def timer(timex):
    2.     time.sleep(timex)
    3. if i[0] == '延时':
    4.     t = int(i[1])
    5.     timer(t)

    连点功能

     有些简单的页面可以通过连点来实现抢票等功能，这个功能必不可少

    记录这个动作的必要参数有连点功能记录、点击频率参数、通过连点次数完成动作还是通过连点时长完成动作。

    同样是调用了获取鼠标位置的函数，

    1. if choose == '连点':
    2.     click_liandian = []
    3.     while 1:
    4.         click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    5.         if click_dongzuo == '1':
    6.             click_weizhi = get_xy()
    7.             click_liandian.append('连点')
    8.             click_liandian.append(click_weizhi)
    9.             break
    10.         elif click_dongzuo == '0':
    11.             print('操作已取消')
    12.             break
    13.         else:
    14.             print('请输入正确的操作（输入“0”或“1”')
    15.     click_pinlv = float(input('请输入连点频率：'))
    16.     while 1:
    17.         click_stop_choose = input('“连点次数”or“连点时长”')
    18.         if click_stop_choose =='连点次数':
    19.             click_cishu = int(input('请输入连点次数：'))
    20.             click_liandian.append('连点次数')
    21.             click_liandian.append(click_cishu)
    22.             click_liandian.append(click_pinlv)
    23.             step.append(click_liandian)
    24.             print(click_liandian)
    25.             print(step)
    26.             break
    27.         if click_stop_choose == '连点时长':
    28.             click_shichang = int(input('请输入连点时长（秒）：'))
    29.             click_liandian.append('连点时长')
    30.             click_liandian.append(click_shichang)
    31.             step.append(click_liandian)
    32.             click_liandian.append(click_pinlv)
    33.             print(click_liandian)
    34.             print(step)
    35.             break
    36.         else:
    37.             continue

    执行时的逻辑：

    1.     if choose == '连点':
    2.         click_liandian = []
    3.         while 1:
    4.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    5.             if click_dongzuo == '1':
    6.                 click_weizhi = get_xy()
    7.                 click_liandian.append('连点')
    8.                 click_liandian.append(click_weizhi)
    9.                 break
    10.             elif click_dongzuo == '0':
    11.                 print('操作已取消')
    12.                 break
    13.             else:
    14.                 print('请输入正确的操作（输入“0”或“1”')
    15.         click_pinlv = float(input('请输入连点频率：'))
    16.         while 1:
    17.             click_stop_choose = input('“连点次数”or“连点时长”')
    18.             if click_stop_choose =='连点次数':
    19.                 click_cishu = int(input('请输入连点次数：'))
    20.                 click_liandian.append('连点次数')
    21.                 click_liandian.append(click_cishu)
    22.                 click_liandian.append(click_pinlv)
    23.                 step.append(click_liandian)
    24.                 print(click_liandian)
    25.                 print(step)
    26.                 break
    27.             if click_stop_choose == '连点时长':
    28.                 click_shichang = int(input('请输入连点时长（秒）：'))
    29.                 click_liandian.append('连点时长')
    30.                 click_liandian.append(click_shichang)
    31.                 step.append(click_liandian)
    32.                 click_liandian.append(click_pinlv)
    33.                 print(click_liandian)
    34.                 print(step)
    35.                 break
    36.             else:
    37.                 continue

    存储功能

    当我们记录完所有操作后我们希望将操作保存下来方便下次使用，不需要从头录入。

    这将生成一个与py脚本同级的txt文件，txt文件中保存了所有的步骤，可直接读取使用

    1.     if choose =='存储':
    2.         if len(step) == 0:
    3.             print('还未记录你任何操作，请添加操作再使用存储功能')
    4.         else:
    5.             do_name = input('请为以上操作命名吧：')
    6.             path = r"{}.txt".format(do_name)
    7.             with open(path, "w",encoding = 'utf8') as f:
    8.                 f.write(str(step))

    读取功能

    这一步呢就稍微麻烦一点，因为txt没办法记录list类型的数据，只能以str类型写出去并且只能以str类型读取进来。我自己定义了一些函数来转化为list类型，比较复杂，就不再说明函数是怎么实现的，日后有机会再跟各位分享。

    1. def writeList2txt(file,data):
    2.     '''
    3.     将list写入txt
    4.     :param data:
    5.     :return:
    6.     '''
    7.     file.write(str(data))
    8.  
    9. def readListFromStr(str):
    10.     '''
    11.     str -> List
    12.     除去冗余的方法调用
    13.     :param str:
    14.     :return:
    15.     '''
    16.     res,pos = help(str,1)
    17.     res1=[]
    18.     a ='1'
    19.     for ii in res:
    20.         iii=[]
    21.         for i in ii:
    22.             if type(i)==type(a):
    23.                 i = i.replace("'", "")
    24.                 iii.append(i)
    25.             else:
    26.                 iii.append(i)
    27.         res1.append(iii)
    28.     return res1
    29.  
    30. def help(str,startIndex):
    31.     '''
    32.     单行字符串的读取，形成list
    33.     :param str:
    34.     :return:
    35.     '''
    36.     str = str.replace(" ","") # 将所有空格删去
    37.     res = []
    38.     i = startIndex
    39.     pre = startIndex
    40.     while i <len(str):
    41.         if str[i] == '[':
    42.             # 将pre-i-2的字符都切片，切split
    43.             if i-2>=pre:
    44.                 slice = str[pre:i-1].split(',')
    45.                 for element in slice:
    46.                     res.append(element)
    47.             # 递归调用 加入子list
    48.             child,pos = help(str,i+1)
    49.             res.append(child)
    50.             i = pos # i移动到pos位置，也就是递归的最后一个右括号
    51.             pre = pos + 2 # 右括号之后是, [ 有三个字符，所以要+2至少
    52.         elif str[i] == ']':
    53.             # 将前面的全部放入列表
    54.             if i-1>=pre:
    55.                 slice = str[pre:i].split(',')
    56.                 for element in slice:
    57.                     res.append(element)
    58.             return res,i
    59.         i = i + 1
    60.  
    61.     return res,i
    62. def get_caozuo(caozuopath):
    63.     with open(caozuopath , 'r' , encoding='utf8') as f:
    64.         data = f.read()
    65.         return data
    66. def get_caozuo_name():
    67.     files1 = []
    68.     file_dir = r"C:\Users\ge\Desktop\test1\我的作品\自定义连点器"
    69.     for root, dirs, files in os.walk(file_dir, topdown=False):
    70.         files = files[:-1]
    71.     for i in files:
    72.         files1.append(i[:-4])
    73.     return files1
    74. print(get_caozuo_name())
    75. if choose == '循环执行':
    76.     caozuojiyi = get_caozuo_name()
    77.     while True:
    78.         xunhuan_choose = input('已存储的操作有：{}\n请输入循环操作的操作名：'.format(caozuojiyi))
    79.         if xunhuan_choose in caozuojiyi:
    80.             break
    81.         else:
    82.             print('存储库中并无你想要的操作，请重新输入：')

    存储导入功能【升级版】

    上面的功能只能把二维的列表导入成list类型的数据类型，不利于后面的导入。一旦存储或导入的列表达到三维或以上就不适用了。后来我在网上搜了半天，终于发现json库里面有方法支持以list的形式导出txt并且可以以list的方式读取。以下是我实现存储导入的逻辑代码：

    导入（功能实现）

    1. def txttolist(path):
    2.     import json
    3.     b = open(path, "r", encoding='UTF-8')
    4.     out = b.read()
    5.     out = json.loads(out)
    6.     return out

    导入（逻辑代码）

    如果程序内存里已有操作了将提示保存

    1.     if choose == '导入':
    2.         if len(step) == 0:
    3.             step = daoru()[0]
    4.         else:
    5.             baocun_choose = input('此次操作若未保存请先，导入别的操作会覆盖原来的操作，你确定要导入吗？\n请输入“yes”or“no”：\n')
    6.             while 1:
    7.                 if baocun_choose == 'no':
    8.                     break
    9.                 if baocun_choose == 'yes':
    10.                     print('你已取消保存')
    11.                     step = daoru()[0]
    12.                     break
    13.                 else:
    14.                     yorn = input("请输入'yes'or'no'：\n")

    存储（功能实现）

    1. def cunchu():
    2.     yorn = input("执行完毕，是否保存？\n输入'yes'or'no'\n")
    3.     while 1:
    4.         if yorn == 'yes':
    5.             if len(step) == 0:
    6.                 print('还未记录你任何操作，请添加操作再使用存储功能')
    7.             else:
    8.                 do_name = input('请为以上操作命名吧：')
    9.                 path = r"{}.txt".format(do_name)
    10.                 listtotxt(list=step, path=path)
    11.             break
    12.         if yorn == 'no':
    13.             print('你已取消存储')
    14.             break
    15.         else:
    16.             yorn = input("请输入'yes'or'no'：\n")
    17.  
    18. def listtotxt(list, path):
    19.     import json
    20.     c_list = list
    21.     c_list = json.dumps(c_list)
    22.     '''将c_list存入文件
    23.     '''
    24.     a = open(path, "w", encoding='UTF-8')
    25.     a.write(c_list)
    26.     a.close()
    27.     print('已存入txt')

    存储（逻辑代码） 

    要是程序内存里还没有操作将提醒

    1.     if choose == '存储':
    2.         if len(step) == 0:
    3.             print('还未记录你任何操作，请添加操作再使用存储功能')
    4.         else:
    5.             do_name = input('请为以上操作命名吧：')
    6.             path = r"{}.txt".format(do_name)
    7.             listtotxt(list=step, path=path)

    拖拽功能

    这个功能也是基于pyautogui库来使用的，主要用到了pyautogui.dragTo（）方法

    功能实现

    1. pyautogui.moveTo(int(i[1][0]), int(i[1][1]))
    2. pyautogui.dragTo(int(i[2][0]), int(i[2][1]), 1, button='left')
    3. print(f'已执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')

    逻辑代码：

    先创建列表tuozhuai，向列表添加三个参数：“拖拽”、第一个位置参数、第二个位置参数

    1.     if choose == '拖拽':
    2.         tuozhuai = []
    3.         while 1:
    4.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成移动前的位置输入，输入“0”取消动作')
    5.             if click_dongzuo == '1':
    6.                 click_weizhi = get_xy()
    7.                 tuozhuai.append('拖拽')
    8.                 tuozhuai.append(click_weizhi)
    9.                 while 1:
    10.                     click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成移动后的位置输入，输入“0”取消动作')
    11.                     if click_dongzuo == '1':
    12.                         click_weizhi = get_xy()
    13.                         tuozhuai.append(click_weizhi)
    14.                         break
    15.                     elif click_dongzuo == '0':
    16.                         print('操作已取消')
    17.                         break
    18.                     else:
    19.                         print('请输入正确的操作（输入“0”或“1”')
    20.                 break
    21.             elif click_dongzuo == '0':
    22.                 print('操作已取消')
    23.                 break
    24.             else:
    25.                 print('请输入正确的操作（输入“0”或“1”')
    26.         step.append(tuozhuai)

    也是用到了pyauogui库，主要使用pyautogui库的pytewrite函数，但是这个函数对中文不友好，于是我另辟蹊径使用pyperclip库的copy函数将要输入的文本内容拷贝打粘贴板，通过控制按键control+v来输入至目标位置。

    功能实现

    1.     if choose == '输入':
    2.         shuru = []
    3.         while 1:
    4.             click_dongzuo = input('请移动鼠标到你要输入的位置上输入“1”完成动作，输入“0”取消动作')
    5.             if click_dongzuo == '1':
    6.                 click_weizhi = get_xy()
    7.                 txt_in = input('请输入你要在该位置输入的文字：\n')
    8.                 shuru.append('输入')
    9.                 shuru.append(click_weizhi)
    10.                 shuru.append(txt_in)
    11.                 step.append(shuru)
    12.                 break
    13.             elif click_dongzuo == '0':
    14.                 print('操作已取消')
    15.                 break
    16.             else:
    17.                 print('请输入正确的操作（输入“0”或“1”')

     逻辑代码

    1.         if i[0] == '输入':
    2.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    3.             pyperclip.copy(i[2])
    4.             time.sleep(0.1)
    5.             pyautogui.hotkey('ctrl', 'v')

    右击、中击、双击功能的实现

    原理相同，将不再赘述

    功能实现

    1.         if i[0] == '双击':
    2.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    3.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    4.             print(f'已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
    5.         if i[0] == '右击':
    6.             x = int(i[1][0])
    7.             y = int(i[1][1])
    8.             pyautogui.rightClick(x, y)
    9.             print(f'已执行完右击动作，点击坐标位置：X：{x},Y：{y}   ')
    10.         if i[0] == '中击':
    11.             x = int(i[1][0])
    12.             y = int(i[1][1])
    13.             pyautogui.middleClick(x, y)
    14.             print(f'已执行完中击动作，点击坐标位置：X：{x},Y：{y}   ')

    逻辑代码

    1.     if choose == '右击':
    2.         click_r = []
    3.         while 1:
    4.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    5.             if click_dongzuo == '1':
    6.                 click_weizhi = get_xy()
    7.                 click_r.append('右击')
    8.                 click_r.append(click_weizhi)
    9.                 step.append(click_r)
    10.                 break
    11.             elif click_dongzuo == '0':
    12.                 print('操作已取消')
    13.                 break
    14.             else:
    15.                 print('请输入正确的操作（输入“0”或“1”')
    16.     if choose == '中击':
    17.         click_m = []
    18.         while 1:
    19.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    20.             if click_dongzuo == '1':
    21.                 click_weizhi = get_xy()
    22.                 click_m.append('中击')
    23.                 click_m.append(click_weizhi)
    24.                 step.append(click_m)
    25.                 break
    26.             elif click_dongzuo == '0':
    27.                 print('操作已取消')
    28.                 break
    29.             else:
    30.                 print('请输入正确的操作（输入“0”或“1”')
    31.         click_double = []
    32.         while 1:
    33.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    34.             if click_dongzuo == '1':
    35.                 click_weizhi = get_xy()
    36.                 click_double.append('双击')
    37.                 click_double.append(click_weizhi)
    38.                 step.append(click_double)
    39.                 break
    40.             elif click_dongzuo == '0':
    41.                 print('操作已取消')
    42.                 break
    43.             else:
    44.                 print('请输入正确的操作（输入“0”或“1”')

    按键功能

    功能实现

    1.         if i[0] == '按键':
    2.             pyautogui.hotkey(*i[1])

    逻辑代码

    1.     if choose == '按键':
    2.         while 1:
    3.             anjian = input('这是模拟操作键盘的操作（例如复制，输入’ctrl‘ + ’c‘）:\n')
    4.             if anjian != 'q':
    5.                 anjian = anjian.split('+')
    6.                 anjians = []
    7.                 a = []
    8.                 for an in anjian:
    9.                     an = an.replace("‘", "").replace("’", "").strip()
    10.                     if an in pyautogui.KEYBOARD_KEYS:
    11.                         anjians.append(an)
    12.                         nihaofan = 0
    13.                     else:
    14.                         print('你的输入不合法')
    15.                         nihaofan = 1
    16.                         break
    17.                 if nihaofan == 0:
    18.                     a.append('按键')
    19.                     a.append(anjians)
    20.                     step.append(a)
    21.                     print('录入成功')
    22.                     break
    23.  
    24.             if anjian == 'q':
    25.                 break

    滚动滚轮功能

    功能实现

    1.         if i[0] == '滚动':
    2.             import pywinauto.mouse
    3.             x, y = pyautogui.position()
    4.             pywinauto.mouse.scroll((x, y), i[1])  # (1100,300)是初始坐标，1000是滑动距离（可负）

    逻辑代码

    1.     if choose == '滚动':
    2.         while 1:
    3.             gundong = []
    4.             try:
    5.                 gundong1 = int(input('这里是模拟鼠标滚动，请输入你要滚动距离（正数为向上移动，负数为向下移动）：\n'))
    6.                 gundong.append('滚动')
    7.                 gundong.append(gundong1)
    8.                 step.append(gundong)
    9.                 break
    10.             except:
    11.                 print('你的输入有误，请重新输入')

    查看功能

    1. def chakan():
    2.     if len(step) == 0:
    3.         print('暂未录入操作，请先录入操作再查看')
    4.     zizeng = 1
    5.     for i in step:
    6.         if i[0] == '点击':
    7.             x = int(i[1][0])
    8.             y = int(i[1][1])
    9.             print(f'第{zizeng}步：\n执行点击动作，点击坐标位置：X：{x},Y：{y}   ')
    10.         if i[0] == '延时':
    11.             t = int(i[1])
    12.             print(f'第{zizeng}步：\n执行延时动作，延时时长：{t}秒')
    13.         if i[0] == '连点':
    14.             if i[2] == '连点次数':
    15.                 print(f'第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
    16.             if i[2] == '连点时长':
    17.                 print(f'第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
    18.         if i[0] == '拖拽':
    19.             print(
    20.                 f'第{zizeng}步：\n执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
    21.         if i[0] == '双击':
    22.             print(f'第{zizeng}步：\n执行点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
    23.  
    24.         if i[0] == '按键':
    25.             print(f'第{zizeng}步：\n执行按键动作，将同时按下”{i[1]}“键')
    26.         zizeng += 1

     执行功能

    执行后将询问是否保存

    1. def zhixing(step):
    2.     for i in step:
    3.         if i[0] == '点击':
    4.             x = int(i[1][0])
    5.             y = int(i[1][1])
    6.             pyautogui.click(x, y)
    7.             print(f'已执行完点击动作，点击坐标位置：X：{x},Y：{y}   ')
    8.         if i[0] == '延时':
    9.             t = int(i[1])
    10.             timer(t)
    11.             print(f'已执行完延时动作，延时时长：{t}秒')
    12.         if i[0] == '连点':
    13.             if i[2] == '连点次数':
    14.                 clicker_cishu(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
    15.                 print(f'已执行完连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
    16.             if i[2] == '连点时长':
    17.                 clicker_time(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
    18.                 print(f'已执行完连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
    19.         if i[0] == '拖拽':
    20.             pyautogui.moveTo(int(i[1][0]), int(i[1][1]))
    21.             pyautogui.dragTo(int(i[2][0]), int(i[2][1]), 1, button='left')
    22.             print(f'已执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
    23.         if i[0] == '双击':
    24.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    25.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    26.             print(f'已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
    27.         if i[0] == '输入':
    28.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    29.             pyperclip.copy(i[2])
    30.             time.sleep(0.1)
    31.             pyautogui.hotkey('ctrl', 'v')
    32.         if i[0] == '按键':
    33.             pyautogui.hotkey(*i[1])
    34.         if i[0] == '右击':
    35.             x = int(i[1][0])
    36.             y = int(i[1][1])
    37.             pyautogui.rightClick(x, y)
    38.             print(f'已执行完右击动作，点击坐标位置：X：{x},Y：{y}   ')
    39.         if i[0] == '中击':
    40.             x = int(i[1][0])
    41.             y = int(i[1][1])
    42.             pyautogui.middleClick(x, y)
    43.             print(f'已执行完中击动作，点击坐标位置：X：{x},Y：{y}   ')
    44.         if i[0] == '滚动':
    45.             import pywinauto.mouse
    46.             x, y = pyautogui.position()
    47.             pywinauto.mouse.scroll((x, y), i[1])  # (1100,300)是初始坐标，1000是滑动距离（可负）
    1.     if choose == '执行':
    2.         if len(step) == 0:
    3.             print('你还未记录任何操作，请至少记录了一个操作再执行')
    4.         else:
    5.             zhixing(step)
    6.             cunchu()

    逻辑判断功能板块

    到了最难最虐脑的逻辑判断功能了，逻辑判断板块这几个功能困扰了我一整天，敲到我脑壳疼

    判断功能

    实现这一功能主要是基于颜色的RBG值来判断程序所要要执行的步骤块。

    选择目标点，开启线程去时刻监管这个目标点的颜色变化，一旦目标颜色变为期待值，立即执行之前存储的步骤块，可以选择是否循环这个步骤块的操作。选择完毕后开启第二个线程去执行这个步骤块，此时主程序将继续遍历panduans的操作。设置一个while循环来阻塞主程序的运行及监控state变量值的变化，state初始值为“未触发”,一旦监管线程发现目标值变化为期待值，立即修改state值为“触发”，同时关闭执行步骤块的线程，同时关闭自身的监管线程，此时主程序检测到state值为“触发”后立刻将新的步骤块的线程开启并将state值修改为“未触发”。就此开启新一轮的循环。

    之间呢，遇到了多个线程修改同一个值的情况导致报错；遇到了多种停止线程的方法都不适用的情况；遇到了没设置守护进程又要找到这个进程去关闭的情况；尝试了老版的_thread进程库、尝试了主流的threading进程库、尝试了线程池的方法，终于找到一条适合我的方法。不容易呀

    判断功能的逻辑代码

    1.     if choose == '判断':
    2.         if len(panduans) == 0:
    3.             tuichu = 0
    4.             panduan = input('此功能的实现是基于颜色的RBG值来判断程序所要要执行的步骤块。\n现在，请选择你的‘先执行步骤块等待条件触发’或是‘直接等待条件触发’的操作：(输入"步骤块"或"等待")\n')
    5.             if panduan == '如果':
    6.                 panduan_if = []
    7.                 while 1:
    8.                     click_dongzuo = input('请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作')
    9.                     if click_dongzuo == '1':
    10.                         xy = get_xy()
    11.                         click_color = GetColor(xy)
    12.                         panduan_yn = input(f'这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n')
    13.                         while 1:
    14.                             if panduan_yn == 'yes':
    15.                                 get_caozuo_name()
    16.                                 print(f'请选择满足当颜色为{click_color}时要执行的步骤包：')
    17.                                 steps, steps_name = daoru()
    18.                                 xunhuan_yn = input('这个步骤块是否循环执行至下一条件触发？（输入"yes"or"no"）\n')
    19.                                 while 1:
    20.                                     if xunhuan_yn == 'yes':
    21.                                         panduan_if.append('如果')
    22.                                         panduan_if.append(xy)
    23.                                         panduan_if.append(click_color)
    24.                                         panduan_if.append(steps_name)
    25.                                         panduan_if.append('循环')
    26.                                         panduan_if.append(steps)
    27.                                         panduans.append(panduan_if)
    28.                                         print('添加成功，该步骤包将会循环')
    29.                                         break
    30.                                     elif xunhuan_yn == 'no':
    31.                                         panduan_if.append('如果')
    32.                                         panduan_if.append(xy)
    33.                                         panduan_if.append(click_color)
    34.                                         panduan_if.append(steps_name)
    35.                                         panduan_if.append('不循环')
    36.                                         panduan_if.append(steps)
    37.                                         panduans.append(panduan_if)
    38.                                         print('添加成功，该步骤包将只执行一次')
    39.                                         break
    40.                                     else:
    41.                                         xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    42.                                 tuichu = 1
    43.                                 break
    44.                             if panduan_yn == 'no':
    45.                                 print('请重新选择')
    46.                                 break
    47.                             else:
    48.                                 panduan_yn = input('你的输入有误，请输入"yes"or"no"')
    49.                         if tuichu == 1:
    50.                             break
    51.                     elif click_dongzuo == '0':
    52.                         print('操作已取消')
    53.                         break
    54.                     else:
    55.                         print('请输入正确的操作（输入“0”或“1”)')
    56.             if panduan == '步骤块':
    57.                 panduan_step = []
    58.                 steps, steps_name = daoru()
    59.                 xunhuan_yn = input('这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n')
    60.                 while 1:
    61.                     if xunhuan_yn == 'yes':
    62.                         panduan_step.append('步骤块')
    63.                         panduan_step.append('循环')
    64.                         panduan_step.append(steps_name)
    65.                         panduan_step.append(steps)
    66.                         panduans.append(panduan_step)
    67.                         break
    68.                     elif xunhuan_yn == 'no':
    69.                         panduan_step.append('步骤块')
    70.                         panduan_step.append('不循环')
    71.                         panduan_step.append(steps_name)
    72.                         panduan_step.append(steps)
    73.                         panduans.append(panduan_step)
    74.                         break
    75.                     else:
    76.                         xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    77.             if panduan == '等待':
    78.                 panduan_if = []
    79.                 print('你选择了等待，程序将时刻检测目标位置的颜色以执行接下来的步骤块')
    80.                 panduan_if.append('等待')
    81.                 panduans.append(panduan_if)
    82.             if panduan != '步骤块' and panduan != '如果' and panduan != '等待':
    83.                 print('你的输入有误')
    84.         if len(panduans) > 0:
    85.             print('你一录入了至少一个逻辑判断，请选择继续选择目标位置的颜色来触发接下来你选择的步骤块')
    86.             panduan_if = []
    87.             while 1:
    88.                 click_dongzuo = input('请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作')
    89.                 if click_dongzuo == '1':
    90.                     xy = get_xy()
    91.                     click_color = GetColor(xy)
    92.                     panduan_yn = input(f'这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n')
    93.                     while 1:
    94.                         if panduan_yn == 'yes':
    95.                             get_caozuo_name()
    96.                             print(f'请选择满足当颜色为{click_color}时要执行的步骤包：')
    97.                             steps, steps_name = daoru()
    98.                             xunhuan_yn = input('这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n')
    99.                             while 1:
    100.                                 if xunhuan_yn == 'yes':
    101.                                     panduan_if.append('如果')
    102.                                     panduan_if.append(xy)
    103.                                     panduan_if.append(click_color)
    104.                                     panduan_if.append(steps_name)
    105.                                     panduan_if.append('循环')
    106.                                     panduan_if.append(steps)
    107.                                     panduans.append(panduan_if)
    108.                                     print('添加成功，该步骤包将会循环')
    109.                                     break
    110.                                 elif xunhuan_yn == 'no':
    111.                                     panduan_if.append('如果')
    112.                                     panduan_if.append(xy)
    113.                                     panduan_if.append(click_color)
    114.                                     panduan_if.append(steps_name)
    115.                                     panduan_if.append('不循环')
    116.                                     panduan_if.append(steps)
    117.                                     panduans.append(panduan_if)
    118.                                     print('添加成功，该步骤包将只执行一次')
    119.                                     break
    120.                                 else:
    121.                                     xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    122.                             tuichu = 1
    123.                             break
    124.                         if panduan_yn == 'no':
    125.                             print('请重新选择')
    126.                             break
    127.                         else:
    128.                             panduan_yn = input('你的输入有误，请输入"yes"or"no"')
    129.                     if tuichu == 1:
    130.                         break
    131.                 elif click_dongzuo == '0':
    132.                     print('操作已取消')
    133.                     break
    134.                 else:
    135.                     print('请输入正确的操作（输入“0”或“1”)')

     逻辑执行功能的实现

    1.     if choose == '逻辑执行':
    2.         print('这里是逻辑执行库，所有的逻辑判断都会存储到这里')
    3.         print(panduans)
    4.         xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=('等待', '1', '循环'))
    5.         xiancheng.setDaemon(True)
    6.         xiancheng.start()
    7.         for pan in panduans:
    8.             state = '未触发'
    9.             if pan[0] == '如果':
    10.                 print(pan[5])
    11.                 print(len(pan[5]))
    12.                 bu = str(pan[5])
    13.                 print(bu)
    14.                 bu = readListFromStr(bu)
    15.                 zhixing(bu)
    16.                 print(bu)
    17.                 if state == '未触发':
    18.                     if pan[4] == '循环':
    19.                         rgb = pan[2]
    20.                         rgb_xy = pan[1]
    21.                         _thread.start_new_thread(jianshi, ())
    22.                         while 1:
    23.                             if state == '触发':
    24.                                 xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], '循环'))
    25.                                 xiancheng.start()
    26.                                 state = '未触发'
    27.                                 break
    28.                     if pan[4] == '不循环':
    29.                         rgb = pan[2]
    30.                         rgb_xy = pan[1]
    31.                         _thread.start_new_thread(jianshi, ())
    32.                         while 1:
    33.                             if state == '触发':
    34.                                 xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], '不循环'))
    35.                                 xiancheng.start()
    36.                                 state = '未触发'
    37.                                 break
    38.             if pan[0] == '步骤块':
    39.                 stop_thread(xiancheng)
    40.                 if pan[1] == '循环':
    41.                     xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], '循环'))
    42.                     xiancheng.start()
    43.                 if pan[1] == '不循环':
    44.                     xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], '不循环'))
    45.                     xiancheng.start()
    46.             if pan[0] == '等待':
    47.                 print('程序正在监测目标位置RGB值')
    48.         print('逻辑执行已全部执行完毕')
    49.         break

    逻辑块存储功能的实现

    1. def listtotxt(list, path):
    2.     import json
    3.     c_list = list
    4.     c_list = json.dumps(c_list)
    5.     '''将c_list存入文件
    6.     '''
    7.     a = open(path, "w", encoding='UTF-8')
    8.     a.write(c_list)
    9.     a.close()
    10.     print('已存入txt')

    逻辑块存储逻辑代码

    1.     if choose == '逻辑块存储':
    2.         yorn = input("确定保存？\n输入'yes'or'no'\n")
    3.         while 1:
    4.             if yorn == 'yes':
    5.                 if len(panduans) == 0:
    6.                     print('还未记录你任何操作，请添加操作再使用逻辑块存储功能')
    7.                 else:
    8.                     do_name = input('请为以上操作命名吧：')
    9.                     if '逻辑块存储' in do_name:
    10.                         do_name = input('抱歉，你的命名里不允许包含”逻辑块存储“，请重新命名')
    11.                     else:
    12.                         path = r"{}逻辑块存储.txt".format(do_name)
    13.                         listtotxt(list=panduans, path=path)
    14.                 break
    15.             if yorn == 'no':
    16.                 print('你已取消存储')
    17.                 break
    18.             else:
    19.                 yorn = input("请输入'yes'or'no'：\n")

    逻辑块导入功能的实现

    1. def txttolist(path):
    2.     import json
    3.     b = open(path, "r", encoding='UTF-8')
    4.     out = b.read()
    5.     out = json.loads(out)
    6.     return out

    逻辑块导入逻辑代码：

    1.     if choose == '逻辑块导入':
    2.         caozuojiyi = get_caozuokuai_name()
    3.         while True:
    4.             xunhuan_choose = input('已存储的操作有：{}\n请输入导入操作的操作名：'.format(caozuojiyi))
    5.             if xunhuan_choose in caozuojiyi:
    6.                 break
    7.             else:
    8.                 print('逻辑块存储库中并无你想要的操作，请重新输入：')
    9.         caozuopath = r"{}逻辑块存储.txt".format(xunhuan_choose)
    10.         panduans = txttolist(path=caozuopath)

    完整代码

    1. import threading
    2. import pyautogui
    3. from ctypes import *
    4. import time
    5. import os, sys
    6. import pyperclip
    7. import inspect
    8. import ctypes
    9. import _thread
    10.  
    11.  
    12. def _async_raise(tid, exctype):
    13.     """raises the exception, performs cleanup if needed"""
    14.     tid = ctypes.c_long(tid)
    15.     if not inspect.isclass(exctype):
    16.         exctype = type(exctype)
    17.     res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
    18.     if res == 0:
    19.         raise ValueError("invalid thread id")
    20.     elif res != 1:
    21.         # """if it returns a number greater than one, you're in trouble,
    22.         # and you should call it again with exc=NULL to revert the effect"""
    23.         ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
    24.         raise SystemError("PyThreadState_SetAsyncExc failed")
    25.  
    26.  
    27. def stop_thread(threa):
    28.     _async_raise(threa.ident, SystemExit)
    29.  
    30.  
    31. def get_caozuo_name():
    32.     dirname, filename = os.path.split(os.path.abspath(sys.argv[0]))
    33.     files1 = []
    34.     file_dir = r"{}".format(os.path.realpath(sys.argv[0])[:-13])
    35.     for root, dirs, files in os.walk(file_dir, topdown=False):
    36.         files = files[:-1]
    37.     for i in files:
    38.         if '.txt' in i:
    39.             files1.append(i[:-4])
    40.     return files1
    41.  
    42.  
    43. def get_caozuokuai_name():
    44.     dirname, filename = os.path.split(os.path.abspath(sys.argv[0]))
    45.     files1 = []
    46.     file_dir = r"{}".format(os.path.realpath(sys.argv[0])[:-13])
    47.     for root, dirs, files in os.walk(file_dir, topdown=False):
    48.         files = files[:-1]
    49.     for i in files:
    50.         if '逻辑块存储.txt' in i:
    51.             files1.append(i[:-9])
    52.     return files1
    53.  
    54.  
    55. def writeList2txt(file, data):
    56.     '''
    57.     将list写入txt
    58.     :param data:
    59.     :return:
    60.     '''
    61.     file.write(str(data), encoding='uft8')
    62.  
    63.  
    64. def readListFromStr(str):
    65.     '''
    66.     str -> List
    67.     除去冗余的方法调用
    68.     :param str:
    69.     :return:
    70.     '''
    71.     res, pos = help(str, 1)
    72.     res1 = []
    73.     a = '1'
    74.     for ii in res:
    75.         iii = []
    76.         for i in ii:
    77.             if type(i) == type(a):
    78.                 i = i.replace("'", "")
    79.                 iii.append(i)
    80.             else:
    81.                 iii.append(i)
    82.         res1.append(iii)
    83.     return res1
    84.  
    85.  
    86. def help(str, startIndex):
    87.     '''
    88.     单行字符串的读取，形成list
    89.     :param str:
    90.     :return:
    91.     '''
    92.     str = str.replace(" ", "")  # 将所有空格删去
    93.     res = []
    94.     i = startIndex
    95.     pre = startIndex
    96.     while i < len(str):
    97.         if str[i] == '[':
    98.             # 将pre-i-2的字符都切片，切split
    99.             if i - 2 >= pre:
    100.                 slice = str[pre:i - 1].split(',')
    101.                 for element in slice:
    102.                     res.append(element)
    103.             # 递归调用 加入子list
    104.             child, pos = help(str, i + 1)
    105.             res.append(child)
    106.             i = pos  # i移动到pos位置，也就是递归的最后一个右括号
    107.             pre = pos + 2  # 右括号之后是, [ 有三个字符，所以要+2至少
    108.         elif str[i] == ']':
    109.             # 将前面的全部放入列表
    110.             if i - 1 >= pre:
    111.                 slice = str[pre:i].split(',')
    112.                 for element in slice:
    113.                     res.append(element)
    114.             return res, i
    115.         i = i + 1
    116.  
    117.     return res, i
    118.  
    119.  
    120. def get_caozuo(caozuopath):
    121.     with open(caozuopath, 'r', encoding='utf8') as f:
    122.         data = f.read()
    123.         return data
    124.  
    125.  
    126. def get_xy():
    127.     x, y = pyautogui.position()
    128.     return [x, y]
    129.  
    130.  
    131. def GetColor(xy):
    132.     x = xy[0]
    133.     y = xy[1]
    134.     r = 0
    135.     g = 0
    136.     b = 0
    137.     try:
    138.         gdi32 = windll.gdi32
    139.         user32 = windll.user32
    140.         hdc = user32.GetDC(None)  # 获取颜色值
    141.         pixel = gdi32.GetPixel(hdc, x, y)  # 提取RGB值
    142.         r = pixel & 0x0000ff
    143.         g = (pixel & 0x00ff00) >> 8
    144.         b = pixel >> 16
    145.     except KeyboardInterrupt:
    146.         print('\n')
    147.     return [r, g, b]
    148.  
    149.  
    150. def timer(timex):
    151.     time.sleep(timex)
    152.  
    153.  
    154. def clicker_cishu(cishu, x, y, pinlv):
    155.     for a in range(cishu):
    156.         pyautogui.click(x, y)
    157.         time.sleep(pinlv)
    158.  
    159.  
    160. def clicker_time(shijian, x, y, pinlv):
    161.     start = time.time()
    162.     while True:
    163.         pyautogui.click(x, y)
    164.         time.sleep(pinlv)
    165.         end = time.time()
    166.         shijian1 = end - start
    167.         if shijian1 >= shijian:
    168.             break
    169.  
    170.  
    171. def zhixing(step):
    172.     for i in step:
    173.         if i[0] == '点击':
    174.             x = int(i[1][0])
    175.             y = int(i[1][1])
    176.             pyautogui.click(x, y)
    177.             print(f'已执行完点击动作，点击坐标位置：X：{x},Y：{y}   ')
    178.         if i[0] == '延时':
    179.             t = int(i[1])
    180.             timer(t)
    181.             print(f'已执行完延时动作，延时时长：{t}秒')
    182.         if i[0] == '连点':
    183.             if i[2] == '连点次数':
    184.                 clicker_cishu(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
    185.                 print(f'已执行完连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
    186.             if i[2] == '连点时长':
    187.                 clicker_time(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
    188.                 print(f'已执行完连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
    189.         if i[0] == '拖拽':
    190.             pyautogui.moveTo(int(i[1][0]), int(i[1][1]))
    191.             pyautogui.dragTo(int(i[2][0]), int(i[2][1]), 1, button='left')
    192.             print(f'已执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
    193.         if i[0] == '双击':
    194.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    195.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    196.             print(f'已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
    197.         if i[0] == '输入':
    198.             pyautogui.click(int(i[1][0]), int(i[1][1]))
    199.             pyperclip.copy(i[2])
    200.             time.sleep(0.1)
    201.             pyautogui.hotkey('ctrl', 'v')
    202.         if i[0] == '按键':
    203.             pyautogui.hotkey(*i[1])
    204.         if i[0] == '右击':
    205.             x = int(i[1][0])
    206.             y = int(i[1][1])
    207.             pyautogui.rightClick(x, y)
    208.             print(f'已执行完右击动作，点击坐标位置：X：{x},Y：{y}   ')
    209.         if i[0] == '中击':
    210.             x = int(i[1][0])
    211.             y = int(i[1][1])
    212.             pyautogui.middleClick(x, y)
    213.             print(f'已执行完中击动作，点击坐标位置：X：{x},Y：{y}   ')
    214.         if i[0] == '滚动':
    215.             import pywinauto.mouse
    216.             x, y = pyautogui.position()
    217.             pywinauto.mouse.scroll((x, y), i[1])  # (1100,300)是初始坐标，1000是滑动距离（可负）
    218.  
    219.  
    220. def cunchu():
    221.     yorn = input("执行完毕，是否保存？\n输入'yes'or'no'\n")
    222.     while 1:
    223.         if yorn == 'yes':
    224.             if len(step) == 0:
    225.                 print('还未记录你任何操作，请添加操作再使用存储功能')
    226.             else:
    227.                 do_name = input('请为以上操作命名吧：')
    228.                 path = r"{}.txt".format(do_name)
    229.                 listtotxt(list=step, path=path)
    230.             break
    231.         if yorn == 'no':
    232.             print('你已取消存储')
    233.             break
    234.         else:
    235.             yorn = input("请输入'yes'or'no'：\n")
    236.  
    237.  
    238. def chakan():
    239.     if len(step) == 0:
    240.         print('暂未录入操作，请先录入操作再查看')
    241.     zizeng = 1
    242.     for i in step:
    243.         if i[0] == '点击':
    244.             x = int(i[1][0])
    245.             y = int(i[1][1])
    246.             print(f'第{zizeng}步：\n执行点击动作，点击坐标位置：X：{x},Y：{y}   ')
    247.         if i[0] == '延时':
    248.             t = int(i[1])
    249.             print(f'第{zizeng}步：\n执行延时动作，延时时长：{t}秒')
    250.         if i[0] == '连点':
    251.             if i[2] == '连点次数':
    252.                 print(f'第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
    253.             if i[2] == '连点时长':
    254.                 print(f'第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
    255.         if i[0] == '拖拽':
    256.             print(
    257.                 f'第{zizeng}步：\n执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
    258.         if i[0] == '双击':
    259.             print(f'第{zizeng}步：\n执行点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
    260.  
    261.         if i[0] == '按键':
    262.             print(f'第{zizeng}步：\n执行按键动作，将同时按下”{i[1]}“键')
    263.         zizeng += 1
    264.  
    265.  
    266. def daoru():
    267.     caozuojiyi = get_caozuo_name()
    268.     while True:
    269.         xunhuan_choose = input('已存储的操作有：{}\n请输入导入操作的操作名：'.format(caozuojiyi))
    270.         if xunhuan_choose in caozuojiyi:
    271.             break
    272.         else:
    273.             print('存储库中并无你想要的操作，请重新输入：')
    274.     caozuopath = r'{}.txt'.format(xunhuan_choose)
    275.     step1 = txttolist(caozuopath)
    276.     print(step1)
    277.     return [step1, xunhuan_choose]
    278.  
    279.  
    280. def jianshi():
    281.     global state, rgb, rgb_xy, xiancheng
    282.     while 1:
    283.         aa = GetColor(rgb_xy)
    284.         if aa == rgb:
    285.             try:
    286.                 stop_thread(xiancheng)
    287.             finally:
    288.  
    289.                 state = '触发'
    290.                 print(f'检测到{rgb_xy}位置的RGB值变为{aa}')
    291.                 break
    292.  
    293.  
    294. def zhixingbuzhoukuai(buzhou, bu, xunhuanyn):
    295.     global state
    296.     print(f'正在执行"{buzhou}"代码块的操作')
    297.     state = '未触发'
    298.     if bu == '1':
    299.         while 1:
    300.             if state == '触发':
    301.                 break
    302.             if state == '未触发':
    303.                 timer(0.1)
    304.     elif xunhuanyn == '循环':
    305.         while 1:
    306.             if state == '触发':
    307.                 break
    308.             if state == '未触发':
    309.                 zhixing(bu)
    310.     elif xunhuanyn == '不循环':
    311.         zhixing(bu)
    312.  
    313.  
    314. def listtotxt(list, path):
    315.     import json
    316.     c_list = list
    317.     c_list = json.dumps(c_list)
    318.     '''将c_list存入文件
    319.     '''
    320.     a = open(path, "w", encoding='UTF-8')
    321.     a.write(c_list)
    322.     a.close()
    323.     print('已存入txt')
    324.  
    325.  
    326. def txttolist(path):
    327.     import json
    328.     b = open(path, "r", encoding='UTF-8')
    329.     out = b.read()
    330.     out = json.loads(out)
    331.     return out
    332.  
    333.  
    334. rgb_xy = []
    335. rgb = []
    336. state = '未触发'
    337. panduans = []
    338. step = []
    339. while True:
    340.     choose = input('请输入你需要使用的功能：')
    341.     if choose == '点击':
    342.         click = []
    343.         while 1:
    344.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    345.             if click_dongzuo == '1':
    346.                 click_weizhi = get_xy()
    347.                 click.append('点击')
    348.                 click.append(click_weizhi)
    349.                 step.append(click)
    350.                 break
    351.             elif click_dongzuo == '0':
    352.                 print('操作已取消')
    353.                 break
    354.             else:
    355.                 print('请输入正确的操作（输入“0”或“1”')
    356.     if choose == '延时':
    357.         while 1:
    358.             timerr = []
    359.             try:
    360.                 timex = int(input('请输入延时时间：'))
    361.                 timerr.append('延时')
    362.                 timerr.append(timex)
    363.                 step.append(timerr)
    364.                 break
    365.             except:
    366.                 print('延时失败/n请输入正确的延时时间')
    367.                 continue
    368.     if choose == '连点':
    369.         click_liandian = []
    370.         while 1:
    371.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    372.             if click_dongzuo == '1':
    373.                 click_weizhi = get_xy()
    374.                 click_liandian.append('连点')
    375.                 click_liandian.append(click_weizhi)
    376.                 break
    377.             elif click_dongzuo == '0':
    378.                 print('操作已取消')
    379.                 break
    380.             else:
    381.                 print('请输入正确的操作（输入“0”或“1”')
    382.         click_pinlv = float(input('请输入连点频率：'))
    383.         while 1:
    384.             click_stop_choose = input('“连点次数”or“连点时长”')
    385.             if click_stop_choose == '连点次数':
    386.                 click_cishu = int(input('请输入连点次数：'))
    387.                 click_liandian.append('连点次数')
    388.                 click_liandian.append(click_cishu)
    389.                 click_liandian.append(click_pinlv)
    390.                 step.append(click_liandian)
    391.                 print(click_liandian)
    392.                 print(step)
    393.                 break
    394.             if click_stop_choose == '连点时长':
    395.                 click_shichang = int(input('请输入连点时长（秒）：'))
    396.                 click_liandian.append('连点时长')
    397.                 click_liandian.append(click_shichang)
    398.                 step.append(click_liandian)
    399.                 click_liandian.append(click_pinlv)
    400.                 print(click_liandian)
    401.                 print(step)
    402.                 break
    403.             else:
    404.                 continue
    405.     if choose == '存储':
    406.         if len(step) == 0:
    407.             print('还未记录你任何操作，请添加操作再使用存储功能')
    408.         else:
    409.             do_name = input('请为以上操作命名吧：')
    410.             path = r"{}.txt".format(do_name)
    411.             listtotxt(list=step, path=path)
    412.     if choose == '拖拽':
    413.         tuozhuai = []
    414.         while 1:
    415.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成移动前的位置输入，输入“0”取消动作')
    416.             if click_dongzuo == '1':
    417.                 click_weizhi = get_xy()
    418.                 tuozhuai.append('拖拽')
    419.                 tuozhuai.append(click_weizhi)
    420.                 while 1:
    421.                     click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成移动后的位置输入，输入“0”取消动作')
    422.                     if click_dongzuo == '1':
    423.                         click_weizhi = get_xy()
    424.                         tuozhuai.append(click_weizhi)
    425.                         break
    426.                     elif click_dongzuo == '0':
    427.                         print('操作已取消')
    428.                         break
    429.                     else:
    430.                         print('请输入正确的操作（输入“0”或“1”')
    431.                 break
    432.             elif click_dongzuo == '0':
    433.                 print('操作已取消')
    434.                 break
    435.             else:
    436.                 print('请输入正确的操作（输入“0”或“1”')
    437.         step.append(tuozhuai)
    438.     if choose == '循环执行':
    439.         while 1:
    440.             xunhuan_cishu_zhixing = 0
    441.             xunhuan_cishu = input('请输入循环次数（如要无限循环请输入"无限"）：')
    442.             if xunhuan_cishu == '无限':
    443.                 while True:
    444.                     zhixing(step)
    445.             if xunhuan_cishu.isdigit():
    446.  
    447.                 for i in range(int(xunhuan_cishu)):
    448.                     xunhuan_cishu_zhixing += 1
    449.                     zhixing(step)
    450.                     print(f'已完成{xunhuan_cishu_zhixing}次循环')
    451.                 break
    452.             else:
    453.                 print('你的输入有误，请重新输入：')
    454.     if choose == '导入':
    455.         if len(step) == 0:
    456.             step = daoru()[0]
    457.         else:
    458.             baocun_choose = input('此次操作若未保存请先，导入别的操作会覆盖原来的操作，你确定要导入吗？\n请输入“yes”or“no”：\n')
    459.             while 1:
    460.                 if baocun_choose == 'no':
    461.                     break
    462.                 if baocun_choose == 'yes':
    463.                     print('你已取消保存')
    464.                     step = daoru()[0]
    465.                     break
    466.                 else:
    467.                     yorn = input("请输入'yes'or'no'：\n")
    468.     if choose == '输入':
    469.         shuru = []
    470.         while 1:
    471.             click_dongzuo = input('请移动鼠标到你要输入的位置上输入“1”完成动作，输入“0”取消动作')
    472.             if click_dongzuo == '1':
    473.                 click_weizhi = get_xy()
    474.                 txt_in = input('请输入你要在该位置输入的文字：\n')
    475.                 shuru.append('输入')
    476.                 shuru.append(click_weizhi)
    477.                 shuru.append(txt_in)
    478.                 step.append(shuru)
    479.                 break
    480.             elif click_dongzuo == '0':
    481.                 print('操作已取消')
    482.                 break
    483.             else:
    484.                 print('请输入正确的操作（输入“0”或“1”')
    485.     if choose == '按键':
    486.         while 1:
    487.             anjian = input('这是模拟操作键盘的操作（例如复制，输入’ctrl‘ + ’c‘）:\n')
    488.             if anjian != 'q':
    489.                 anjian = anjian.split('+')
    490.                 anjians = []
    491.                 a = []
    492.                 for an in anjian:
    493.                     an = an.replace("‘", "").replace("’", "").strip()
    494.                     if an in pyautogui.KEYBOARD_KEYS:
    495.                         anjians.append(an)
    496.                         nihaofan = 0
    497.                     else:
    498.                         print('你的输入不合法')
    499.                         nihaofan = 1
    500.                         break
    501.                 if nihaofan == 0:
    502.                     a.append('按键')
    503.                     a.append(anjians)
    504.                     step.append(a)
    505.                     print('录入成功')
    506.                     break
    507.  
    508.             if anjian == 'q':
    509.                 break
    510.     if choose == '双击':
    511.         click_double = []
    512.         while 1:
    513.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    514.             if click_dongzuo == '1':
    515.                 click_weizhi = get_xy()
    516.                 click_double.append('双击')
    517.                 click_double.append(click_weizhi)
    518.                 step.append(click_double)
    519.                 break
    520.             elif click_dongzuo == '0':
    521.                 print('操作已取消')
    522.                 break
    523.             else:
    524.                 print('请输入正确的操作（输入“0”或“1”')
    525.     if choose == '滚动':
    526.         while 1:
    527.             gundong = []
    528.             try:
    529.                 gundong1 = int(input('这里是模拟鼠标滚动，请输入你要滚动距离（正数为向上移动，负数为向下移动）：\n'))
    530.                 gundong.append('滚动')
    531.                 gundong.append(gundong1)
    532.                 step.append(gundong)
    533.                 break
    534.             except:
    535.                 print('你的输入有误，请重新输入')
    536.     if choose == '查看':
    537.         chakan()
    538.     if choose == '右击':
    539.         click_r = []
    540.         while 1:
    541.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    542.             if click_dongzuo == '1':
    543.                 click_weizhi = get_xy()
    544.                 click_r.append('右击')
    545.                 click_r.append(click_weizhi)
    546.                 step.append(click_r)
    547.                 break
    548.             elif click_dongzuo == '0':
    549.                 print('操作已取消')
    550.                 break
    551.             else:
    552.                 print('请输入正确的操作（输入“0”或“1”')
    553.     if choose == '中击':
    554.         click_m = []
    555.         while 1:
    556.             click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
    557.             if click_dongzuo == '1':
    558.                 click_weizhi = get_xy()
    559.                 click_m.append('中击')
    560.                 click_m.append(click_weizhi)
    561.                 step.append(click_m)
    562.                 break
    563.             elif click_dongzuo == '0':
    564.                 print('操作已取消')
    565.                 break
    566.             else:
    567.                 print('请输入正确的操作（输入“0”或“1”')
    568.     if choose == '执行':
    569.         if len(step) == 0:
    570.             print('你还未记录任何操作，请至少记录了一个操作再执行')
    571.         else:
    572.             zhixing(step)
    573.             cunchu()
    574.     if choose == '判断':
    575.         if len(panduans) == 0:
    576.             tuichu = 0
    577.             panduan = input('此功能的实现是基于颜色的RBG值来判断程序所要要执行的步骤块。\n现在，请选择你的‘先执行步骤块等待条件触发’或是‘直接等待条件触发’的操作：(输入"步骤块"或"等待")\n')
    578.             if panduan == '如果':
    579.                 panduan_if = []
    580.                 while 1:
    581.                     click_dongzuo = input('请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作')
    582.                     if click_dongzuo == '1':
    583.                         xy = get_xy()
    584.                         click_color = GetColor(xy)
    585.                         panduan_yn = input(f'这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n')
    586.                         while 1:
    587.                             if panduan_yn == 'yes':
    588.                                 get_caozuo_name()
    589.                                 print(f'请选择满足当颜色为{click_color}时要执行的步骤包：')
    590.                                 steps, steps_name = daoru()
    591.                                 xunhuan_yn = input('这个步骤块是否循环执行至下一条件触发？（输入"yes"or"no"）\n')
    592.                                 while 1:
    593.                                     if xunhuan_yn == 'yes':
    594.                                         panduan_if.append('如果')
    595.                                         panduan_if.append(xy)
    596.                                         panduan_if.append(click_color)
    597.                                         panduan_if.append(steps_name)
    598.                                         panduan_if.append('循环')
    599.                                         panduan_if.append(steps)
    600.                                         panduans.append(panduan_if)
    601.                                         print('添加成功，该步骤包将会循环')
    602.                                         break
    603.                                     elif xunhuan_yn == 'no':
    604.                                         panduan_if.append('如果')
    605.                                         panduan_if.append(xy)
    606.                                         panduan_if.append(click_color)
    607.                                         panduan_if.append(steps_name)
    608.                                         panduan_if.append('不循环')
    609.                                         panduan_if.append(steps)
    610.                                         panduans.append(panduan_if)
    611.                                         print('添加成功，该步骤包将只执行一次')
    612.                                         break
    613.                                     else:
    614.                                         xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    615.                                 tuichu = 1
    616.                                 break
    617.                             if panduan_yn == 'no':
    618.                                 print('请重新选择')
    619.                                 break
    620.                             else:
    621.                                 panduan_yn = input('你的输入有误，请输入"yes"or"no"')
    622.                         if tuichu == 1:
    623.                             break
    624.                     elif click_dongzuo == '0':
    625.                         print('操作已取消')
    626.                         break
    627.                     else:
    628.                         print('请输入正确的操作（输入“0”或“1”)')
    629.             if panduan == '步骤块':
    630.                 panduan_step = []
    631.                 steps, steps_name = daoru()
    632.                 xunhuan_yn = input('这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n')
    633.                 while 1:
    634.                     if xunhuan_yn == 'yes':
    635.                         panduan_step.append('步骤块')
    636.                         panduan_step.append('循环')
    637.                         panduan_step.append(steps_name)
    638.                         panduan_step.append(steps)
    639.                         panduans.append(panduan_step)
    640.                         break
    641.                     elif xunhuan_yn == 'no':
    642.                         panduan_step.append('步骤块')
    643.                         panduan_step.append('不循环')
    644.                         panduan_step.append(steps_name)
    645.                         panduan_step.append(steps)
    646.                         panduans.append(panduan_step)
    647.                         break
    648.                     else:
    649.                         xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    650.             if panduan == '等待':
    651.                 panduan_if = []
    652.                 print('你选择了等待，程序将时刻检测目标位置的颜色以执行接下来的步骤块')
    653.                 panduan_if.append('等待')
    654.                 panduans.append(panduan_if)
    655.             if panduan != '步骤块' and panduan != '如果' and panduan != '等待':
    656.                 print('你的输入有误')
    657.         if len(panduans) > 0:
    658.             print('你一录入了至少一个逻辑判断，请选择继续选择目标位置的颜色来触发接下来你选择的步骤块')
    659.             panduan_if = []
    660.             while 1:
    661.                 click_dongzuo = input('请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作')
    662.                 if click_dongzuo == '1':
    663.                     xy = get_xy()
    664.                     click_color = GetColor(xy)
    665.                     panduan_yn = input(f'这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n')
    666.                     while 1:
    667.                         if panduan_yn == 'yes':
    668.                             get_caozuo_name()
    669.                             print(f'请选择满足当颜色为{click_color}时要执行的步骤包：')
    670.                             steps, steps_name = daoru()
    671.                             xunhuan_yn = input('这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n')
    672.                             while 1:
    673.                                 if xunhuan_yn == 'yes':
    674.                                     panduan_if.append('如果')
    675.                                     panduan_if.append(xy)
    676.                                     panduan_if.append(click_color)
    677.                                     panduan_if.append(steps_name)
    678.                                     panduan_if.append('循环')
    679.                                     panduan_if.append(steps)
    680.                                     panduans.append(panduan_if)
    681.                                     print('添加成功，该步骤包将会循环')
    682.                                     break
    683.                                 elif xunhuan_yn == 'no':
    684.                                     panduan_if.append('如果')
    685.                                     panduan_if.append(xy)
    686.                                     panduan_if.append(click_color)
    687.                                     panduan_if.append(steps_name)
    688.                                     panduan_if.append('不循环')
    689.                                     panduan_if.append(steps)
    690.                                     panduans.append(panduan_if)
    691.                                     print('添加成功，该步骤包将只执行一次')
    692.                                     break
    693.                                 else:
    694.                                     xunhuan_yn = input('你的输入有误，请输入"yes"or"no":')
    695.                             tuichu = 1
    696.                             break
    697.                         if panduan_yn == 'no':
    698.                             print('请重新选择')
    699.                             break
    700.                         else:
    701.                             panduan_yn = input('你的输入有误，请输入"yes"or"no"')
    702.                     if tuichu == 1:
    703.                         break
    704.                 elif click_dongzuo == '0':
    705.                     print('操作已取消')
    706.                     break
    707.                 else:
    708.                     print('请输入正确的操作（输入“0”或“1”)')
    709.     if choose == '逻辑执行':
    710.         print('这里是逻辑执行库，所有的逻辑判断都会存储到这里')
    711.         print(panduans)
    712.         xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=('等待', '1', '循环'))
    713.         xiancheng.setDaemon(True)
    714.         xiancheng.start()
    715.         for pan in panduans:
    716.             state = '未触发'
    717.             if pan[0] == '如果':
    718.                 print(pan[5])
    719.                 print(len(pan[5]))
    720.                 bu = str(pan[5])
    721.                 print(bu)
    722.                 bu = readListFromStr(bu)
    723.                 zhixing(bu)
    724.                 print(bu)
    725.                 if state == '未触发':
    726.                     if pan[4] == '循环':
    727.                         rgb = pan[2]
    728.                         rgb_xy = pan[1]
    729.                         _thread.start_new_thread(jianshi, ())
    730.                         while 1:
    731.                             if state == '触发':
    732.                                 xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], '循环'))
    733.                                 xiancheng.start()
    734.                                 state = '未触发'
    735.                                 break
    736.                     if pan[4] == '不循环':
    737.                         rgb = pan[2]
    738.                         rgb_xy = pan[1]
    739.                         _thread.start_new_thread(jianshi, ())
    740.                         while 1:
    741.                             if state == '触发':
    742.                                 xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], '不循环'))
    743.                                 xiancheng.start()
    744.                                 state = '未触发'
    745.                                 break
    746.             if pan[0] == '步骤块':
    747.                 stop_thread(xiancheng)
    748.                 if pan[1] == '循环':
    749.                     xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], '循环'))
    750.                     xiancheng.start()
    751.                 if pan[1] == '不循环':
    752.                     xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], '不循环'))
    753.                     xiancheng.start()
    754.             if pan[0] == '等待':
    755.                 print('程序正在监测目标位置RGB值')
    756.         print('逻辑执行已全部执行完毕')
    757.         break
    758.     if choose == '逻辑块存储':
    759.         yorn = input("确定保存？\n输入'yes'or'no'\n")
    760.         while 1:
    761.             if yorn == 'yes':
    762.                 if len(panduans) == 0:
    763.                     print('还未记录你任何操作，请添加操作再使用逻辑块存储功能')
    764.                 else:
    765.                     do_name = input('请为以上操作命名吧：')
    766.                     if '逻辑块存储' in do_name:
    767.                         do_name = input('抱歉，你的命名里不允许包含”逻辑块存储“，请重新命名')
    768.                     else:
    769.                         path = r"{}逻辑块存储.txt".format(do_name)
    770.                         listtotxt(list=panduans, path=path)
    771.                 break
    772.             if yorn == 'no':
    773.                 print('你已取消存储')
    774.                 break
    775.             else:
    776.                 yorn = input("请输入'yes'or'no'：\n")
    777.     if choose == '逻辑块导入':
    778.         caozuojiyi = get_caozuokuai_name()
    779.         while True:
    780.             xunhuan_choose = input('已存储的操作有：{}\n请输入导入操作的操作名：'.format(caozuojiyi))
    781.             if xunhuan_choose in caozuojiyi:
    782.                 break
    783.             else:
    784.                 print('逻辑块存储库中并无你想要的操作，请重新输入：')
    785.         caozuopath = r"{}逻辑块存储.txt".format(xunhuan_choose)
    786.         panduans = txttolist(path=caozuopath)
    787.  
    788.     if choose == 'q' or choose == 'quit' or choose == '退出' or choose == 'close':
    789.         break
    790.     if choose == 'tips' or choose == '提示' or choose == 'help' or choose == '帮助':
    791.         print(
    792.             '''你可以输入'点击', '右击', '中击', '逻辑执行', '判断', '滚动', '延时', '存储', '执行', '循环执行', '拖拽', '连点', '输入', '双击', '查看',
    793.                       '导入', 'q', 'quit','退出', 'close', 'tips', '提示', 'help', '帮助', '按键'来帮助你完成你的自动化操作''')
    794.     if not choose in ['点击', '右击', '中击', '逻辑执行', '判断', '滚动', '延时', '存储', '执行', '循环执行', '拖拽', '连点', '输入', '双击', '查看',
    795.                       '导入', 'q', 'quit','退出', 'close', 'tips', '提示', 'help', '帮助', '按键']:
    796.         print('你的输入有误或暂未开发此功能，请重新输入（输入”help“获得提示）')
    797. print('代码已全部执行完毕,程序已退出')

    这是我的2.0版本，之前把逻辑板块之外的功能都写出来了之后迫不及待地玩了一下，帮朋友买了四价，做了微信信息轰炸的程序，看着鼠标把文件夹拖来拖去，做了些拳皇脚本打出超级连招，等会我再试一下盲僧的马氏三角杀哈哈哈，想想就兴奋~~

    本来还想做多点功能的，比如：检测目标区域的文字来执行判断操作（这听起来不难）；

    写个语音输入功能，当执行完什么操作了就让电脑说：“你好厉害啊”、“真的是我的偶像”、“快来看看我抢到四价了”(现在我就能写出来)；

    1. import pyttsx3
    2. engine = pyttsx3.init()
    3. engine.say('我抢到了!快来看一下')
    4. engine.runAndWait()

    当然暂时还没有这些需求，如果我哪天有空就再更新到3.0版本哈，你们感兴趣的可以自己添加功能，至少我语音功能的逻辑代码已经给你们了。真不是懒【偷笑】

    艾玛，居然发了三万多字了，不聊了不聊了。

    不过都发这么多了，最后还是麻烦关注、点赞、收藏下哈。我喜欢在我的博客上分享一些有趣的代码，我跟别人不一样，我不卖课~~纯分享~~喜欢回复私信和留言~~~~     

    不定期更新~~~~

  • 相关阅读:
    杰理之AT 包格式【篇】
    用户身份标识与账号体系实践
    【Linux】进程间通信
    浅谈BIM技术在“智慧工地”建设中的应用
    go 线程限制数量v1 --chatGPT
    第7章 访问控制技术原理与应用
    Linux网络编程：网络协议及网络传输的基本流程
    【云原生】手把手教你搭建ferry开源工单系统
    ICML2021 | RSD: 一种基于几何距离的可迁移回归表征学习方法
    SpringBoot的基本使用
  • 原文地址：https://blog.csdn.net/m0_62814033/article/details/126231082