検索

ホームページ >バックエンド開発 >Python チュートリアル >Python を使用してカスタム ドット コネクタを実装する方法

Python を使用してカスタム ドット コネクタを実装する方法

王林
王林転載
2023-05-12 20:43:042853ブラウズ

    まえがき

    数日前、母が四価ワクチンの予約が取れないことに気づき、プログラムを書こうと思いました。人間をシミュレートするには 操作をクリックしてワクチンが手に入れられたかどうかを確認し、このページを無限ループで更新します。ワクチンが予約可能になったら、すぐにワクチンを取得して、その人にワクチン接種する時間を選択します。予約が成功すると、音声ループが「もう予約されました。来て見に来てください」とアナウンスします。

    上記のアイデアとニーズに基づいて、次のコードの編集に 30 分を費やし、1 時間以内に予約を取ることに成功しました。 

    import pyautogui
from ctypes import *  # 获取屏幕上某个坐标的颜色
from time import sleep
import time
 
start = time.time()
def get_color(x, y):
    gdi32 = windll.gdi32
    user32 = windll.user32
    hdc = user32.GetDC(None)  # 获取颜色值
    pixel = gdi32.GetPixel(hdc, x, y)  # 提取RGB值
    r = pixel & 0x0000ff
    g = (pixel & 0x00ff00) >> 8
    b = pixel >> 16
    return [r, g, b]
print(get_color(297,454))
while True:
    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]:
        pyautogui.click(310,255)#点进去抢
        sleep(0.5)
        pyautogui.click(467,262)#选择预约时间
        while True:
            if get_color(297,454) == [0,142,255]:
                break
            else:
                sleep(0.3)
        sleep(0.5)
        pyautogui.click(498,454)#点击下午
        sleep(0.5)
        pyautogui.click(467,520)#选择时间
        sleep(0.5)
        pyautogui.click(470,899)#点选好了
        sleep(0.5)
        pyautogui.click(470, 899)#点立即预约
        #sleep()
        break
    else:
        pyautogui.click(123,60)
        sleep(0.8)#刷新
print('总耗时：'.format(time.time()-start))
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
while 1:
    import pyttsx3
    engine = pyttsx3.init()
    engine.say('我抢到了!快来看一下')
    engine.runAndWait()
    sleep(1)

    実装アイデアの大まかなフローチャート:

    Python を使用してカスタム ドット コネクタを実装する方法

    必要な機能を実現するためのロジックは非常に単純であることがわかりますが、それでも、それでもコードを書くのに30分近くかかりました。それで、将来的にチケットを取得したり、スキルコンボをしたり、友達に情報を送り込んだりする機能を開発したいと思ったら、そんなに時間がかかるだろうか? だったら、ホイールを自分で作ってすぐに開発できるようにできないだろうかと考えていました。スキルは何ですか? どのようなスクリプトが必要ですか?

    全体的なアイデア

    一般的に必要な機能は、クリック、遅延、ポイントの接続、およびドラッグです。基本的にはこの 4 つの機能で簡単な補助スクリプトの開発は完了しますが、もう少し高度な機能を追加したいので、ループ、判定、擬似キーストローク、テキスト入力、ストレージ操作などを追加開発したいと考えています。 , 読み取り操作のための関数。

    次に、実現したい 9 つの主要機能 (ループ、クリック、遅延、点の接続、ドラッグ アンド ドロップ、判定、模擬キー、テキスト入力、保存操作、読み取り操作) に向けて開発する必要があります。

    まず第一に、操作のすべてのステップがプログラムによって記録され、実行されることを望みます。各操作を保存するリストを定義できます。リスト内の各要素は各ステップの操作であり、次に、このリストをたどって各操作を読み取って実行すると、操作全体が完了します。

    操作のすべてのステップが入力された後、次回使用するためにプログラムが自動的に保存され、次回再度コンパイルする必要がなくなることを願っています。

    各リストの 0 番目の項目が操作する必要がある関数で、0 番目の項目以降に各種パラメータが続きます。

    すべての機能

    簡単なデモンストレーション

    Python を使用してカスタム ドット コネクタを実装する方法

    クリック機能

    コンピュータにクリックしてもらいたい場合は、まずどこをクリックするかをコンピュータに伝える必要があります。マウスの位置を取得したい場合は、pyautogui ライブラリを使用する必要があり、このライブラリにはマウスの位置の X 座標と Y 座標を返す Position() メソッドがあります。

    位置取得関数を定義する

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

    オブジェクト指向の考え方を使用してプログラムを簡素化し、コードの再利用率を高め、プログラムを読みやすくすることは、Python 開発における重要なアイデアの 1 つです

    pyautogui ライブラリには、多くの共通関数もあります。興味がある場合は、以前に書いたブログを参照してください: Python クイック チュートリアル: selenium のようなコンピューターの操作の詳細な説明

    関数コードは次のとおりです

    step=[]
while True:
    choose = input('请输入你需要使用的功能：')
    if choose == '点击':
        click = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click.append('点击')
                click.append(click_weizhi)
                step.append(click)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')

    実行中のロジック

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

    クリックを記録するには、クリック関数と位置パラメータを記録してリストを生成し、そのリストを合計ステップ リストに追加する必要があります

    Delay 関数

    Python 組み込みライブラリの time モジュールを使用すると、プログラムを対応する時間に強制的に停止できます。パラメータ生成リストをステップ合計リストに追加します 

    if choose =='延时':
    while 1:
        timerr = []
        try:
            timex = int(input('请输入延时时间：'))
            timerr.append('延时')
            timerr.append(timex)
            step.append(timerr)
            break
        except:
            print('延时失败/n请输入正确的延时时间')
            continue

    実行ロジック 

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

    接続ドット関数

    いくつかの単純なページでは、ドットと他の関数を接続することでチケット取得を実現できます。関数は必須です

    このアクションを記録するために必要なパラメータには、接続ポイント機能レコード、クリック頻度パラメータ、アクションが接続ポイントの数または接続ポイントの継続時間によって完了するかどうかが含まれます。

    マウスの位置を取得する関数も呼び出されます。 

    if choose == '连点':
    click_liandian = []
    while 1:
        click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
        if click_dongzuo == '1':
            click_weizhi = get_xy()
            click_liandian.append('连点')
            click_liandian.append(click_weizhi)
            break
        elif click_dongzuo == '0':
            print('操作已取消')
            break
        else:
            print('请输入正确的操作（输入“0”或“1”')
    click_pinlv = float(input('请输入连点频率：'))
    while 1:
        click_stop_choose = input('“连点次数”or“连点时长”')
        if click_stop_choose =='连点次数':
            click_cishu = int(input('请输入连点次数：'))
            click_liandian.append('连点次数')
            click_liandian.append(click_cishu)
            click_liandian.append(click_pinlv)
            step.append(click_liandian)
            print(click_liandian)
            print(step)
            break
        if click_stop_choose == '连点时长':
            click_shichang = int(input('请输入连点时长（秒）：'))
            click_liandian.append('连点时长')
            click_liandian.append(click_shichang)
            step.append(click_liandian)
            click_liandian.append(click_pinlv)
            print(click_liandian)
            print(step)
            break
        else:
            continue

    実行中のロジック

        if choose == '连点':
        click_liandian = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click_liandian.append('连点')
                click_liandian.append(click_weizhi)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
        click_pinlv = float(input('请输入连点频率：'))
        while 1:
            click_stop_choose = input('“连点次数”or“连点时长”')
            if click_stop_choose =='连点次数':
                click_cishu = int(input('请输入连点次数：'))
                click_liandian.append('连点次数')
                click_liandian.append(click_cishu)
                click_liandian.append(click_pinlv)
                step.append(click_liandian)
                print(click_liandian)
                print(step)
                break
            if click_stop_choose == '连点时长':
                click_shichang = int(input('请输入连点时长（秒）：'))
                click_liandian.append('连点时长')
                click_liandian.append(click_shichang)
                step.append(click_liandian)
                click_liandian.append(click_pinlv)
                print(click_liandian)
                print(step)
                break
            else:
                continue

    ストレージ関数

    すべての操作を記録した後、次回簡単に使用できるように、最初から入力せずに操作を保存したいと考えています。

    これにより、py スクリプトと同じレベルで txt ファイルが生成されます。すべてのステップは txt ファイルに保存され、

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

    reading 関数を使用して直接読み取ることができます

    This 最初の手順は少し面倒で、txt にはリスト型のデータを記録することができず、str 型でしか書き出すことができず、str 型でしか読み込むことができません。リスト型に変換する関数をいくつか自分で定義しましたが、かなり複雑なので実装方法については割愛しますので、機会があれば紹介したいと思います。 

    def writeList2txt(file,data):
    '''
    将list写入txt
    :param data:
    :return:
    '''
    file.write(str(data))
 
def readListFromStr(str):
    '''
    str -> List
    除去冗余的方法调用
    :param str:
    :return:
    '''
    res,pos = help(str,1)
    res1=[]
    a ='1'
    for ii in res:
        iii=[]
        for i in ii:
            if type(i)==type(a):
                i = i.replace("'", "")
                iii.append(i)
            else:
                iii.append(i)
        res1.append(iii)
    return res1
 
def help(str,startIndex):
    '''
    单行字符串的读取，形成list
    :param str:
    :return:
    '''
    str = str.replace(" ","") # 将所有空格删去
    res = []
    i = startIndex
    pre = startIndex
    while i <len(str):
        if str[i] == &#39;[&#39;:
            # 将pre-i-2的字符都切片，切split
            if i-2>=pre:
                slice = str[pre:i-1].split(&#39;,&#39;)
                for element in slice:
                    res.append(element)
            # 递归调用 加入子list
            child,pos = help(str,i+1)
            res.append(child)
            i = pos # i移动到pos位置，也就是递归的最后一个右括号
            pre = pos + 2 # 右括号之后是, [ 有三个字符，所以要+2至少
        elif str[i] == &#39;]&#39;:
            # 将前面的全部放入列表
            if i-1>=pre:
                slice = str[pre:i].split(&#39;,&#39;)
                for element in slice:
                    res.append(element)
            return res,i
        i = i + 1
 
    return res,i
def get_caozuo(caozuopath):
    with open(caozuopath , &#39;r&#39; , encoding=&#39;utf8&#39;) as f:
        data = f.read()
        return data
def get_caozuo_name():
    files1 = []
    file_dir = r"C:\Users\ge\Desktop\test1\我的作品\自定义连点器"
    for root, dirs, files in os.walk(file_dir, topdown=False):
        files = files[:-1]
    for i in files:
        files1.append(i[:-4])
    return files1
print(get_caozuo_name())
if choose == &#39;循环执行&#39;:
    caozuojiyi = get_caozuo_name()
    while True:
        xunhuan_choose = input(&#39;已存储的操作有：{}\n请输入循环操作的操作名：&#39;.format(caozuojiyi))
        if xunhuan_choose in caozuojiyi:
            break
        else:
            print(&#39;存储库中并无你想要的操作，请重新输入：&#39;)

    ストレージ インポート関数 [アップグレード バージョン]

    上記の関数は、2 次元リストをリスト型データ型にインポートすることしかできないため、後続のインポートには役立ちません。これは、保存またはインポートされたリストが 3 次元以上になると適用されません。その後、インターネットを長い間検索した結果、json ライブラリに txt をリスト形式でエクスポートすることをサポートし、それをリスト形式で読み取ることができるメソッドがあることがわかりました。以下は、ストレージ インポートの実装に使用するロジック コードです。

    Import (関数実装) 

    def txttolist(path):
    import json
    b = open(path, "r", encoding=&#39;UTF-8&#39;)
    out = b.read()
    out = json.loads(out)
    return out

    Import (ロジック コード) 

        if choose == &#39;导入&#39;:
        if len(step) == 0:
            step = daoru()[0]
        else:
            baocun_choose = input(&#39;此次操作若未保存请先，导入别的操作会覆盖原来的操作，你确定要导入吗？\n请输入“yes”or“no”：\n&#39;)
            while 1:
                if baocun_choose == &#39;no&#39;:
                    break
                if baocun_choose == &#39;yes&#39;:
                    print(&#39;你已取消保存&#39;)
                    step = daoru()[0]
                    break
                else:
                    yorn = input("请输入&#39;yes&#39;or&#39;no&#39;：\n")

    ストレージ (関数実装) 

    def cunchu():
    yorn = input("执行完毕，是否保存？\n输入&#39;yes&#39;or&#39;no&#39;\n")
    while 1:
        if yorn == &#39;yes&#39;:
            if len(step) == 0:
                print(&#39;还未记录你任何操作，请添加操作再使用存储功能&#39;)
            else:
                do_name = input(&#39;请为以上操作命名吧：&#39;)
                path = r"{}.txt".format(do_name)
                listtotxt(list=step, path=path)
            break
        if yorn == &#39;no&#39;:
            print(&#39;你已取消存储&#39;)
            break
        else:
            yorn = input("请输入&#39;yes&#39;or&#39;no&#39;：\n")
 
def listtotxt(list, path):
    import json
    c_list = list
    c_list = json.dumps(c_list)
    &#39;&#39;&#39;将c_list存入文件
    &#39;&#39;&#39;
    a = open(path, "w", encoding=&#39;UTF-8&#39;)
    a.write(c_list)
    a.close()
    print(&#39;已存入txt&#39;)

    ストレージ (ロジック コード)

    プログラム メモリに操作がない場合、それはあなたに思い出させます

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

    拖拽功能

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

    功能实现

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

    逻辑代码：

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

        if choose == &#39;拖拽&#39;:
        tuozhuai = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成移动前的位置输入，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                tuozhuai.append(&#39;拖拽&#39;)
                tuozhuai.append(click_weizhi)
                while 1:
                    click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成移动后的位置输入，输入“0”取消动作&#39;)
                    if click_dongzuo == &#39;1&#39;:
                        click_weizhi = get_xy()
                        tuozhuai.append(click_weizhi)
                        break
                    elif click_dongzuo == &#39;0&#39;:
                        print(&#39;操作已取消&#39;)
                        break
                    else:
                        print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
        step.append(tuozhuai)

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

    功能实现

        if choose == &#39;输入&#39;:
        shuru = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到你要输入的位置上输入“1”完成动作，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                txt_in = input(&#39;请输入你要在该位置输入的文字：\n&#39;)
                shuru.append(&#39;输入&#39;)
                shuru.append(click_weizhi)
                shuru.append(txt_in)
                step.append(shuru)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)

     逻辑代码

            if i[0] == &#39;输入&#39;:
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyperclip.copy(i[2])
            time.sleep(0.1)
            pyautogui.hotkey(&#39;ctrl&#39;, &#39;v&#39;)

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

    原理相同，将不再赘述

    功能实现

            if i[0] == &#39;双击&#39;:
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            print(f&#39;已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   &#39;)
        if i[0] == &#39;右击&#39;:
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.rightClick(x, y)
            print(f&#39;已执行完右击动作，点击坐标位置：X：{x},Y：{y}   &#39;)
        if i[0] == &#39;中击&#39;:
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.middleClick(x, y)
            print(f&#39;已执行完中击动作，点击坐标位置：X：{x},Y：{y}   &#39;)

    逻辑代码

        if choose == &#39;右击&#39;:
        click_r = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                click_r.append(&#39;右击&#39;)
                click_r.append(click_weizhi)
                step.append(click_r)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
    if choose == &#39;中击&#39;:
        click_m = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                click_m.append(&#39;中击&#39;)
                click_m.append(click_weizhi)
                step.append(click_m)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
        click_double = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                click_double.append(&#39;双击&#39;)
                click_double.append(click_weizhi)
                step.append(click_double)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)

    按键功能

    功能实现

            if i[0] == &#39;按键&#39;:
            pyautogui.hotkey(*i[1])

    逻辑代码

        if choose == &#39;按键&#39;:
        while 1:
            anjian = input(&#39;这是模拟操作键盘的操作（例如复制，输入&#39;ctrl‘ + &#39;c‘）:\n&#39;)
            if anjian != &#39;q&#39;:
                anjian = anjian.split(&#39;+&#39;)
                anjians = []
                a = []
                for an in anjian:
                    an = an.replace("‘", "").replace("&#39;", "").strip()
                    if an in pyautogui.KEYBOARD_KEYS:
                        anjians.append(an)
                        nihaofan = 0
                    else:
                        print(&#39;你的输入不合法&#39;)
                        nihaofan = 1
                        break
                if nihaofan == 0:
                    a.append(&#39;按键&#39;)
                    a.append(anjians)
                    step.append(a)
                    print(&#39;录入成功&#39;)
                    break
 
            if anjian == &#39;q&#39;:
                break

    滚动滚轮功能

    功能实现

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

    逻辑代码

        if choose == &#39;滚动&#39;:
        while 1:
            gundong = []
            try:
                gundong1 = int(input(&#39;这里是模拟鼠标滚动，请输入你要滚动距离（正数为向上移动，负数为向下移动）：\n&#39;))
                gundong.append(&#39;滚动&#39;)
                gundong.append(gundong1)
                step.append(gundong)
                break
            except:
                print(&#39;你的输入有误，请重新输入&#39;)

    查看功能

    def chakan():
    if len(step) == 0:
        print(&#39;暂未录入操作，请先录入操作再查看&#39;)
    zizeng = 1
    for i in step:
        if i[0] == &#39;点击&#39;:
            x = int(i[1][0])
            y = int(i[1][1])
            print(f&#39;第{zizeng}步：\n执行点击动作，点击坐标位置：X：{x},Y：{y}   &#39;)
        if i[0] == &#39;延时&#39;:
            t = int(i[1])
            print(f&#39;第{zizeng}步：\n执行延时动作，延时时长：{t}秒&#39;)
        if i[0] == &#39;连点&#39;:
            if i[2] == &#39;连点次数&#39;:
                print(f&#39;第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点次数是{i[4]}&#39;)
            if i[2] == &#39;连点时长&#39;:
                print(f&#39;第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒&#39;)
        if i[0] == &#39;拖拽&#39;:
            print(
                f&#39;第{zizeng}步：\n执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}&#39;)
        if i[0] == &#39;双击&#39;:
            print(f&#39;第{zizeng}步：\n执行点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   &#39;)
 
        if i[0] == &#39;按键&#39;:
            print(f&#39;第{zizeng}步：\n执行按键动作，将同时按下”{i[1]}“键&#39;)
        zizeng += 1

    执行功能

    执行后将询问是否保存

    def zhixing(step):
    for i in step:
        if i[0] == '点击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.click(x, y)
            print(f'已执行完点击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == '延时':
            t = int(i[1])
            timer(t)
            print(f'已执行完延时动作，延时时长：{t}秒')
        if i[0] == '连点':
            if i[2] == '连点次数':
                clicker_cishu(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
                print(f'已执行完连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
            if i[2] == '连点时长':
                clicker_time(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
                print(f'已执行完连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
        if i[0] == '拖拽':
            pyautogui.moveTo(int(i[1][0]), int(i[1][1]))
            pyautogui.dragTo(int(i[2][0]), int(i[2][1]), 1, button='left')
            print(f'已执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
        if i[0] == '双击':
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            print(f'已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
        if i[0] == &#39;输入&#39;:
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyperclip.copy(i[2])
            time.sleep(0.1)
            pyautogui.hotkey(&#39;ctrl&#39;, &#39;v&#39;)
        if i[0] == &#39;按键&#39;:
            pyautogui.hotkey(*i[1])
        if i[0] == '右击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.rightClick(x, y)
            print(f'已执行完右击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == '中击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.middleClick(x, y)
            print(f'已执行完中击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == &#39;滚动&#39;:
            import pywinauto.mouse
            x, y = pyautogui.position()
            pywinauto.mouse.scroll((x, y), i[1])  # (1100,300)是初始坐标，1000是滑动距离（可负）
        if choose == &#39;执行&#39;:
        if len(step) == 0:
            print(&#39;你还未记录任何操作，请至少记录了一个操作再执行&#39;)
        else:
            zhixing(step)
            cunchu()

    逻辑判断功能板块

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

    判断功能

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

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

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

    判断功能的逻辑代码

        if choose == &#39;判断&#39;:
        if len(panduans) == 0:
            tuichu = 0
            panduan = input(&#39;此功能的实现是基于颜色的RBG值来判断程序所要要执行的步骤块。\n现在，请选择你的‘先执行步骤块等待条件触发&#39;或是‘直接等待条件触发&#39;的操作：(输入"步骤块"或"等待")\n&#39;)
            if panduan == &#39;如果&#39;:
                panduan_if = []
                while 1:
                    click_dongzuo = input(&#39;请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作&#39;)
                    if click_dongzuo == &#39;1&#39;:
                        xy = get_xy()
                        click_color = GetColor(xy)
                        panduan_yn = input(f&#39;这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n&#39;)
                        while 1:
                            if panduan_yn == &#39;yes&#39;:
                                get_caozuo_name()
                                print(f&#39;请选择满足当颜色为{click_color}时要执行的步骤包：&#39;)
                                steps, steps_name = daoru()
                                xunhuan_yn = input(&#39;这个步骤块是否循环执行至下一条件触发？（输入"yes"or"no"）\n&#39;)
                                while 1:
                                    if xunhuan_yn == &#39;yes&#39;:
                                        panduan_if.append(&#39;如果&#39;)
                                        panduan_if.append(xy)
                                        panduan_if.append(click_color)
                                        panduan_if.append(steps_name)
                                        panduan_if.append(&#39;循环&#39;)
                                        panduan_if.append(steps)
                                        panduans.append(panduan_if)
                                        print(&#39;添加成功，该步骤包将会循环&#39;)
                                        break
                                    elif xunhuan_yn == &#39;no&#39;:
                                        panduan_if.append(&#39;如果&#39;)
                                        panduan_if.append(xy)
                                        panduan_if.append(click_color)
                                        panduan_if.append(steps_name)
                                        panduan_if.append(&#39;不循环&#39;)
                                        panduan_if.append(steps)
                                        panduans.append(panduan_if)
                                        print(&#39;添加成功，该步骤包将只执行一次&#39;)
                                        break
                                    else:
                                        xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
                                tuichu = 1
                                break
                            if panduan_yn == &#39;no&#39;:
                                print(&#39;请重新选择&#39;)
                                break
                            else:
                                panduan_yn = input(&#39;你的输入有误，请输入"yes"or"no"&#39;)
                        if tuichu == 1:
                            break
                    elif click_dongzuo == &#39;0&#39;:
                        print(&#39;操作已取消&#39;)
                        break
                    else:
                        print(&#39;请输入正确的操作（输入“0”或“1”)&#39;)
            if panduan == &#39;步骤块&#39;:
                panduan_step = []
                steps, steps_name = daoru()
                xunhuan_yn = input(&#39;这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n&#39;)
                while 1:
                    if xunhuan_yn == &#39;yes&#39;:
                        panduan_step.append(&#39;步骤块&#39;)
                        panduan_step.append(&#39;循环&#39;)
                        panduan_step.append(steps_name)
                        panduan_step.append(steps)
                        panduans.append(panduan_step)
                        break
                    elif xunhuan_yn == &#39;no&#39;:
                        panduan_step.append(&#39;步骤块&#39;)
                        panduan_step.append(&#39;不循环&#39;)
                        panduan_step.append(steps_name)
                        panduan_step.append(steps)
                        panduans.append(panduan_step)
                        break
                    else:
                        xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
            if panduan == &#39;等待&#39;:
                panduan_if = []
                print(&#39;你选择了等待，程序将时刻检测目标位置的颜色以执行接下来的步骤块&#39;)
                panduan_if.append(&#39;等待&#39;)
                panduans.append(panduan_if)
            if panduan != &#39;步骤块&#39; and panduan != &#39;如果&#39; and panduan != &#39;等待&#39;:
                print(&#39;你的输入有误&#39;)
        if len(panduans) > 0:
            print(&#39;你一录入了至少一个逻辑判断，请选择继续选择目标位置的颜色来触发接下来你选择的步骤块&#39;)
            panduan_if = []
            while 1:
                click_dongzuo = input(&#39;请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作&#39;)
                if click_dongzuo == &#39;1&#39;:
                    xy = get_xy()
                    click_color = GetColor(xy)
                    panduan_yn = input(f&#39;这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n&#39;)
                    while 1:
                        if panduan_yn == &#39;yes&#39;:
                            get_caozuo_name()
                            print(f&#39;请选择满足当颜色为{click_color}时要执行的步骤包：&#39;)
                            steps, steps_name = daoru()
                            xunhuan_yn = input(&#39;这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n&#39;)
                            while 1:
                                if xunhuan_yn == &#39;yes&#39;:
                                    panduan_if.append(&#39;如果&#39;)
                                    panduan_if.append(xy)
                                    panduan_if.append(click_color)
                                    panduan_if.append(steps_name)
                                    panduan_if.append(&#39;循环&#39;)
                                    panduan_if.append(steps)
                                    panduans.append(panduan_if)
                                    print(&#39;添加成功，该步骤包将会循环&#39;)
                                    break
                                elif xunhuan_yn == &#39;no&#39;:
                                    panduan_if.append(&#39;如果&#39;)
                                    panduan_if.append(xy)
                                    panduan_if.append(click_color)
                                    panduan_if.append(steps_name)
                                    panduan_if.append(&#39;不循环&#39;)
                                    panduan_if.append(steps)
                                    panduans.append(panduan_if)
                                    print(&#39;添加成功，该步骤包将只执行一次&#39;)
                                    break
                                else:
                                    xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
                            tuichu = 1
                            break
                        if panduan_yn == &#39;no&#39;:
                            print(&#39;请重新选择&#39;)
                            break
                        else:
                            panduan_yn = input(&#39;你的输入有误，请输入"yes"or"no"&#39;)
                    if tuichu == 1:
                        break
                elif click_dongzuo == &#39;0&#39;:
                    print(&#39;操作已取消&#39;)
                    break
                else:
                    print(&#39;请输入正确的操作（输入“0”或“1”)&#39;)

    逻辑执行功能的实现

        if choose == &#39;逻辑执行&#39;:
        print(&#39;这里是逻辑执行库，所有的逻辑判断都会存储到这里&#39;)
        print(panduans)
        xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(&#39;等待&#39;, &#39;1&#39;, &#39;循环&#39;))
        xiancheng.setDaemon(True)
        xiancheng.start()
        for pan in panduans:
            state = &#39;未触发&#39;
            if pan[0] == &#39;如果&#39;:
                print(pan[5])
                print(len(pan[5]))
                bu = str(pan[5])
                print(bu)
                bu = readListFromStr(bu)
                zhixing(bu)
                print(bu)
                if state == &#39;未触发&#39;:
                    if pan[4] == &#39;循环&#39;:
                        rgb = pan[2]
                        rgb_xy = pan[1]
                        _thread.start_new_thread(jianshi, ())
                        while 1:
                            if state == &#39;触发&#39;:
                                xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], &#39;循环&#39;))
                                xiancheng.start()
                                state = &#39;未触发&#39;
                                break
                    if pan[4] == &#39;不循环&#39;:
                        rgb = pan[2]
                        rgb_xy = pan[1]
                        _thread.start_new_thread(jianshi, ())
                        while 1:
                            if state == &#39;触发&#39;:
                                xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], &#39;不循环&#39;))
                                xiancheng.start()
                                state = &#39;未触发&#39;
                                break
            if pan[0] == &#39;步骤块&#39;:
                stop_thread(xiancheng)
                if pan[1] == &#39;循环&#39;:
                    xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], &#39;循环&#39;))
                    xiancheng.start()
                if pan[1] == &#39;不循环&#39;:
                    xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], &#39;不循环&#39;))
                    xiancheng.start()
            if pan[0] == &#39;等待&#39;:
                print(&#39;程序正在监测目标位置RGB值&#39;)
        print(&#39;逻辑执行已全部执行完毕&#39;)
        break

    逻辑块存储功能的实现

    def listtotxt(list, path):
    import json
    c_list = list
    c_list = json.dumps(c_list)
    &#39;&#39;&#39;将c_list存入文件
    &#39;&#39;&#39;
    a = open(path, "w", encoding=&#39;UTF-8&#39;)
    a.write(c_list)
    a.close()
    print(&#39;已存入txt&#39;)

    逻辑块存储逻辑代码

        if choose == &#39;逻辑块存储&#39;:
        yorn = input("确定保存？\n输入&#39;yes&#39;or&#39;no&#39;\n")
        while 1:
            if yorn == &#39;yes&#39;:
                if len(panduans) == 0:
                    print(&#39;还未记录你任何操作，请添加操作再使用逻辑块存储功能&#39;)
                else:
                    do_name = input(&#39;请为以上操作命名吧：&#39;)
                    if &#39;逻辑块存储&#39; in do_name:
                        do_name = input(&#39;抱歉，你的命名里不允许包含”逻辑块存储“，请重新命名&#39;)
                    else:
                        path = r"{}逻辑块存储.txt".format(do_name)
                        listtotxt(list=panduans, path=path)
                break
            if yorn == &#39;no&#39;:
                print(&#39;你已取消存储&#39;)
                break
            else:
                yorn = input("请输入&#39;yes&#39;or&#39;no&#39;：\n")

    逻辑块导入功能的实现

    def txttolist(path):
    import json
    b = open(path, "r", encoding=&#39;UTF-8&#39;)
    out = b.read()
    out = json.loads(out)
    return out

    逻辑块导入逻辑代码

        if choose == &#39;逻辑块导入&#39;:
        caozuojiyi = get_caozuokuai_name()
        while True:
            xunhuan_choose = input(&#39;已存储的操作有：{}\n请输入导入操作的操作名：&#39;.format(caozuojiyi))
            if xunhuan_choose in caozuojiyi:
                break
            else:
                print(&#39;逻辑块存储库中并无你想要的操作，请重新输入：&#39;)
        caozuopath = r"{}逻辑块存储.txt".format(xunhuan_choose)
        panduans = txttolist(path=caozuopath)

    完整代码

    import threading
import pyautogui
from ctypes import *
import time
import os, sys
import pyperclip
import inspect
import ctypes
import _thread
 
 
def _async_raise(tid, exctype):
    """raises the exception, performs cleanup if needed"""
    tid = ctypes.c_long(tid)
    if not inspect.isclass(exctype):
        exctype = type(exctype)
    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
    if res == 0:
        raise ValueError("invalid thread id")
    elif res != 1:
        # """if it returns a number greater than one, you're in trouble,
        # and you should call it again with exc=NULL to revert the effect"""
        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
        raise SystemError("PyThreadState_SetAsyncExc failed")
 
 
def stop_thread(threa):
    _async_raise(threa.ident, SystemExit)
 
 
def get_caozuo_name():
    dirname, filename = os.path.split(os.path.abspath(sys.argv[0]))
    files1 = []
    file_dir = r"{}".format(os.path.realpath(sys.argv[0])[:-13])
    for root, dirs, files in os.walk(file_dir, topdown=False):
        files = files[:-1]
    for i in files:
        if '.txt' in i:
            files1.append(i[:-4])
    return files1
 
 
def get_caozuokuai_name():
    dirname, filename = os.path.split(os.path.abspath(sys.argv[0]))
    files1 = []
    file_dir = r"{}".format(os.path.realpath(sys.argv[0])[:-13])
    for root, dirs, files in os.walk(file_dir, topdown=False):
        files = files[:-1]
    for i in files:
        if '逻辑块存储.txt' in i:
            files1.append(i[:-9])
    return files1
 
 
def writeList2txt(file, data):
    '''
    将list写入txt
    :param data:
    :return:
    '''
    file.write(str(data), encoding='uft8')
 
 
def readListFromStr(str):
    '''
    str -> List
    除去冗余的方法调用
    :param str:
    :return:
    '''
    res, pos = help(str, 1)
    res1 = []
    a = '1'
    for ii in res:
        iii = []
        for i in ii:
            if type(i) == type(a):
                i = i.replace("'", "")
                iii.append(i)
            else:
                iii.append(i)
        res1.append(iii)
    return res1
 
 
def help(str, startIndex):
    '''
    单行字符串的读取，形成list
    :param str:
    :return:
    '''
    str = str.replace(" ", "")  # 将所有空格删去
    res = []
    i = startIndex
    pre = startIndex
    while i < len(str):
        if str[i] == '[':
            # 将pre-i-2的字符都切片，切split
            if i - 2 >= pre:
                slice = str[pre:i - 1].split(',')
                for element in slice:
                    res.append(element)
            # 递归调用 加入子list
            child, pos = help(str, i + 1)
            res.append(child)
            i = pos  # i移动到pos位置，也就是递归的最后一个右括号
            pre = pos + 2  # 右括号之后是, [ 有三个字符，所以要+2至少
        elif str[i] == ']':
            # 将前面的全部放入列表
            if i - 1 >= pre:
                slice = str[pre:i].split(',')
                for element in slice:
                    res.append(element)
            return res, i
        i = i + 1
 
    return res, i
 
 
def get_caozuo(caozuopath):
    with open(caozuopath, 'r', encoding='utf8') as f:
        data = f.read()
        return data
 
 
def get_xy():
    x, y = pyautogui.position()
    return [x, y]
 
 
def GetColor(xy):
    x = xy[0]
    y = xy[1]
    r = 0
    g = 0
    b = 0
    try:
        gdi32 = windll.gdi32
        user32 = windll.user32
        hdc = user32.GetDC(None)  # 获取颜色值
        pixel = gdi32.GetPixel(hdc, x, y)  # 提取RGB值
        r = pixel & 0x0000ff
        g = (pixel & 0x00ff00) >> 8
        b = pixel >> 16
    except KeyboardInterrupt:
        print('\n')
    return [r, g, b]
 
 
def timer(timex):
    time.sleep(timex)
 
 
def clicker_cishu(cishu, x, y, pinlv):
    for a in range(cishu):
        pyautogui.click(x, y)
        time.sleep(pinlv)
 
 
def clicker_time(shijian, x, y, pinlv):
    start = time.time()
    while True:
        pyautogui.click(x, y)
        time.sleep(pinlv)
        end = time.time()
        shijian1 = end - start
        if shijian1 >= shijian:
            break
 
 
def zhixing(step):
    for i in step:
        if i[0] == '点击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.click(x, y)
            print(f'已执行完点击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == '延时':
            t = int(i[1])
            timer(t)
            print(f'已执行完延时动作，延时时长：{t}秒')
        if i[0] == '连点':
            if i[2] == '连点次数':
                clicker_cishu(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
                print(f'已执行完连点操作，你选择的是{i[2]}，连点次数是{i[4]}')
            if i[2] == '连点时长':
                clicker_time(int(i[3]), int(i[1][0]), int(i[1][1]), int(i[4]))
                print(f'已执行完连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒')
        if i[0] == '拖拽':
            pyautogui.moveTo(int(i[1][0]), int(i[1][1]))
            pyautogui.dragTo(int(i[2][0]), int(i[2][1]), 1, button='left')
            print(f'已执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}')
        if i[0] == '双击':
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            print(f'已执行完点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   ')
        if i[0] == &#39;输入&#39;:
            pyautogui.click(int(i[1][0]), int(i[1][1]))
            pyperclip.copy(i[2])
            time.sleep(0.1)
            pyautogui.hotkey(&#39;ctrl&#39;, &#39;v&#39;)
        if i[0] == &#39;按键&#39;:
            pyautogui.hotkey(*i[1])
        if i[0] == '右击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.rightClick(x, y)
            print(f'已执行完右击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == '中击':
            x = int(i[1][0])
            y = int(i[1][1])
            pyautogui.middleClick(x, y)
            print(f'已执行完中击动作，点击坐标位置：X：{x},Y：{y}   ')
        if i[0] == &#39;滚动&#39;:
            import pywinauto.mouse
            x, y = pyautogui.position()
            pywinauto.mouse.scroll((x, y), i[1])  # (1100,300)是初始坐标，1000是滑动距离（可负）
 
 
def cunchu():
    yorn = input("执行完毕，是否保存？\n输入'yes'or'no'\n")
    while 1:
        if yorn == 'yes':
            if len(step) == 0:
                print('还未记录你任何操作，请添加操作再使用存储功能')
            else:
                do_name = input('请为以上操作命名吧：')
                path = r"{}.txt".format(do_name)
                listtotxt(list=step, path=path)
            break
        if yorn == 'no':
            print('你已取消存储')
            break
        else:
            yorn = input("请输入'yes'or'no'：\n")
 
 
def chakan():
    if len(step) == 0:
        print(&#39;暂未录入操作，请先录入操作再查看&#39;)
    zizeng = 1
    for i in step:
        if i[0] == &#39;点击&#39;:
            x = int(i[1][0])
            y = int(i[1][1])
            print(f&#39;第{zizeng}步：\n执行点击动作，点击坐标位置：X：{x},Y：{y}   &#39;)
        if i[0] == &#39;延时&#39;:
            t = int(i[1])
            print(f&#39;第{zizeng}步：\n执行延时动作，延时时长：{t}秒&#39;)
        if i[0] == &#39;连点&#39;:
            if i[2] == &#39;连点次数&#39;:
                print(f&#39;第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点次数是{i[4]}&#39;)
            if i[2] == &#39;连点时长&#39;:
                print(f&#39;第{zizeng}步：\n执行连点操作，你选择的是{i[2]}，连点时长是{i[4]}秒&#39;)
        if i[0] == &#39;拖拽&#39;:
            print(
                f&#39;第{zizeng}步：\n执行拖拽动作，拖拽起始位置是X:{int(i[1][0])}，Y:{int(i[1][1])},拖拽后的位置是X:{int(i[2][0])}，Y:{int(i[2][1])}&#39;)
        if i[0] == &#39;双击&#39;:
            print(f&#39;第{zizeng}步：\n执行点击动作，点击坐标位置：X：{int(i[1][0])},Y：{int(i[1][1])}   &#39;)
 
        if i[0] == &#39;按键&#39;:
            print(f&#39;第{zizeng}步：\n执行按键动作，将同时按下”{i[1]}“键&#39;)
        zizeng += 1
 
 
def daoru():
    caozuojiyi = get_caozuo_name()
    while True:
        xunhuan_choose = input('已存储的操作有：{}\n请输入导入操作的操作名：'.format(caozuojiyi))
        if xunhuan_choose in caozuojiyi:
            break
        else:
            print('存储库中并无你想要的操作，请重新输入：')
    caozuopath = r'{}.txt'.format(xunhuan_choose)
    step1 = txttolist(caozuopath)
    print(step1)
    return [step1, xunhuan_choose]
 
 
def jianshi():
    global state, rgb, rgb_xy, xiancheng
    while 1:
        aa = GetColor(rgb_xy)
        if aa == rgb:
            try:
                stop_thread(xiancheng)
            finally:
 
                state = '触发'
                print(f'检测到{rgb_xy}位置的RGB值变为{aa}')
                break
 
 
def zhixingbuzhoukuai(buzhou, bu, xunhuanyn):
    global state
    print(f'正在执行"{buzhou}"代码块的操作')
    state = '未触发'
    if bu == '1':
        while 1:
            if state == '触发':
                break
            if state == '未触发':
                timer(0.1)
    elif xunhuanyn == '循环':
        while 1:
            if state == '触发':
                break
            if state == '未触发':
                zhixing(bu)
    elif xunhuanyn == '不循环':
        zhixing(bu)
 
 
def listtotxt(list, path):
    import json
    c_list = list
    c_list = json.dumps(c_list)
    &#39;&#39;&#39;将c_list存入文件
    &#39;&#39;&#39;
    a = open(path, "w", encoding=&#39;UTF-8&#39;)
    a.write(c_list)
    a.close()
    print(&#39;已存入txt&#39;)
 
 
def txttolist(path):
    import json
    b = open(path, "r", encoding=&#39;UTF-8&#39;)
    out = b.read()
    out = json.loads(out)
    return out
 
 
rgb_xy = []
rgb = []
state = '未触发'
panduans = []
step = []
while True:
    choose = input('请输入你需要使用的功能：')
    if choose == '点击':
        click = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click.append('点击')
                click.append(click_weizhi)
                step.append(click)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
    if choose == '延时':
        while 1:
            timerr = []
            try:
                timex = int(input('请输入延时时间：'))
                timerr.append('延时')
                timerr.append(timex)
                step.append(timerr)
                break
            except:
                print('延时失败/n请输入正确的延时时间')
                continue
    if choose == '连点':
        click_liandian = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click_liandian.append('连点')
                click_liandian.append(click_weizhi)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
        click_pinlv = float(input('请输入连点频率：'))
        while 1:
            click_stop_choose = input('“连点次数”or“连点时长”')
            if click_stop_choose == '连点次数':
                click_cishu = int(input('请输入连点次数：'))
                click_liandian.append('连点次数')
                click_liandian.append(click_cishu)
                click_liandian.append(click_pinlv)
                step.append(click_liandian)
                print(click_liandian)
                print(step)
                break
            if click_stop_choose == '连点时长':
                click_shichang = int(input('请输入连点时长（秒）：'))
                click_liandian.append('连点时长')
                click_liandian.append(click_shichang)
                step.append(click_liandian)
                click_liandian.append(click_pinlv)
                print(click_liandian)
                print(step)
                break
            else:
                continue
    if choose == &#39;存储&#39;:
        if len(step) == 0:
            print(&#39;还未记录你任何操作，请添加操作再使用存储功能&#39;)
        else:
            do_name = input(&#39;请为以上操作命名吧：&#39;)
            path = r"{}.txt".format(do_name)
            listtotxt(list=step, path=path)
    if choose == &#39;拖拽&#39;:
        tuozhuai = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成移动前的位置输入，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                tuozhuai.append(&#39;拖拽&#39;)
                tuozhuai.append(click_weizhi)
                while 1:
                    click_dongzuo = input(&#39;请移动鼠标到目标位置上输入“1”完成移动后的位置输入，输入“0”取消动作&#39;)
                    if click_dongzuo == &#39;1&#39;:
                        click_weizhi = get_xy()
                        tuozhuai.append(click_weizhi)
                        break
                    elif click_dongzuo == &#39;0&#39;:
                        print(&#39;操作已取消&#39;)
                        break
                    else:
                        print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
        step.append(tuozhuai)
    if choose == '循环执行':
        while 1:
            xunhuan_cishu_zhixing = 0
            xunhuan_cishu = input('请输入循环次数（如要无限循环请输入"无限"）：')
            if xunhuan_cishu == '无限':
                while True:
                    zhixing(step)
            if xunhuan_cishu.isdigit():
 
                for i in range(int(xunhuan_cishu)):
                    xunhuan_cishu_zhixing += 1
                    zhixing(step)
                    print(f'已完成{xunhuan_cishu_zhixing}次循环')
                break
            else:
                print('你的输入有误，请重新输入：')
    if choose == &#39;导入&#39;:
        if len(step) == 0:
            step = daoru()[0]
        else:
            baocun_choose = input(&#39;此次操作若未保存请先，导入别的操作会覆盖原来的操作，你确定要导入吗？\n请输入“yes”or“no”：\n&#39;)
            while 1:
                if baocun_choose == &#39;no&#39;:
                    break
                if baocun_choose == &#39;yes&#39;:
                    print(&#39;你已取消保存&#39;)
                    step = daoru()[0]
                    break
                else:
                    yorn = input("请输入&#39;yes&#39;or&#39;no&#39;：\n")
    if choose == &#39;输入&#39;:
        shuru = []
        while 1:
            click_dongzuo = input(&#39;请移动鼠标到你要输入的位置上输入“1”完成动作，输入“0”取消动作&#39;)
            if click_dongzuo == &#39;1&#39;:
                click_weizhi = get_xy()
                txt_in = input(&#39;请输入你要在该位置输入的文字：\n&#39;)
                shuru.append(&#39;输入&#39;)
                shuru.append(click_weizhi)
                shuru.append(txt_in)
                step.append(shuru)
                break
            elif click_dongzuo == &#39;0&#39;:
                print(&#39;操作已取消&#39;)
                break
            else:
                print(&#39;请输入正确的操作（输入“0”或“1”&#39;)
    if choose == &#39;按键&#39;:
        while 1:
            anjian = input(&#39;这是模拟操作键盘的操作（例如复制，输入&#39;ctrl‘ + &#39;c‘）:\n&#39;)
            if anjian != &#39;q&#39;:
                anjian = anjian.split(&#39;+&#39;)
                anjians = []
                a = []
                for an in anjian:
                    an = an.replace("‘", "").replace("&#39;", "").strip()
                    if an in pyautogui.KEYBOARD_KEYS:
                        anjians.append(an)
                        nihaofan = 0
                    else:
                        print(&#39;你的输入不合法&#39;)
                        nihaofan = 1
                        break
                if nihaofan == 0:
                    a.append(&#39;按键&#39;)
                    a.append(anjians)
                    step.append(a)
                    print(&#39;录入成功&#39;)
                    break
 
            if anjian == &#39;q&#39;:
                break
    if choose == '双击':
        click_double = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click_double.append('双击')
                click_double.append(click_weizhi)
                step.append(click_double)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
    if choose == &#39;滚动&#39;:
        while 1:
            gundong = []
            try:
                gundong1 = int(input(&#39;这里是模拟鼠标滚动，请输入你要滚动距离（正数为向上移动，负数为向下移动）：\n&#39;))
                gundong.append(&#39;滚动&#39;)
                gundong.append(gundong1)
                step.append(gundong)
                break
            except:
                print(&#39;你的输入有误，请重新输入&#39;)
    if choose == '查看':
        chakan()
    if choose == '右击':
        click_r = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click_r.append('右击')
                click_r.append(click_weizhi)
                step.append(click_r)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
    if choose == '中击':
        click_m = []
        while 1:
            click_dongzuo = input('请移动鼠标到目标位置上输入“1”完成动作，输入“0”取消动作')
            if click_dongzuo == '1':
                click_weizhi = get_xy()
                click_m.append('中击')
                click_m.append(click_weizhi)
                step.append(click_m)
                break
            elif click_dongzuo == '0':
                print('操作已取消')
                break
            else:
                print('请输入正确的操作（输入“0”或“1”')
    if choose == &#39;执行&#39;:
        if len(step) == 0:
            print(&#39;你还未记录任何操作，请至少记录了一个操作再执行&#39;)
        else:
            zhixing(step)
            cunchu()
    if choose == &#39;判断&#39;:
        if len(panduans) == 0:
            tuichu = 0
            panduan = input(&#39;此功能的实现是基于颜色的RBG值来判断程序所要要执行的步骤块。\n现在，请选择你的‘先执行步骤块等待条件触发&#39;或是‘直接等待条件触发&#39;的操作：(输入"步骤块"或"等待")\n&#39;)
            if panduan == &#39;如果&#39;:
                panduan_if = []
                while 1:
                    click_dongzuo = input(&#39;请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作&#39;)
                    if click_dongzuo == &#39;1&#39;:
                        xy = get_xy()
                        click_color = GetColor(xy)
                        panduan_yn = input(f&#39;这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n&#39;)
                        while 1:
                            if panduan_yn == &#39;yes&#39;:
                                get_caozuo_name()
                                print(f&#39;请选择满足当颜色为{click_color}时要执行的步骤包：&#39;)
                                steps, steps_name = daoru()
                                xunhuan_yn = input(&#39;这个步骤块是否循环执行至下一条件触发？（输入"yes"or"no"）\n&#39;)
                                while 1:
                                    if xunhuan_yn == &#39;yes&#39;:
                                        panduan_if.append(&#39;如果&#39;)
                                        panduan_if.append(xy)
                                        panduan_if.append(click_color)
                                        panduan_if.append(steps_name)
                                        panduan_if.append(&#39;循环&#39;)
                                        panduan_if.append(steps)
                                        panduans.append(panduan_if)
                                        print(&#39;添加成功，该步骤包将会循环&#39;)
                                        break
                                    elif xunhuan_yn == &#39;no&#39;:
                                        panduan_if.append(&#39;如果&#39;)
                                        panduan_if.append(xy)
                                        panduan_if.append(click_color)
                                        panduan_if.append(steps_name)
                                        panduan_if.append(&#39;不循环&#39;)
                                        panduan_if.append(steps)
                                        panduans.append(panduan_if)
                                        print(&#39;添加成功，该步骤包将只执行一次&#39;)
                                        break
                                    else:
                                        xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
                                tuichu = 1
                                break
                            if panduan_yn == &#39;no&#39;:
                                print(&#39;请重新选择&#39;)
                                break
                            else:
                                panduan_yn = input(&#39;你的输入有误，请输入"yes"or"no"&#39;)
                        if tuichu == 1:
                            break
                    elif click_dongzuo == &#39;0&#39;:
                        print(&#39;操作已取消&#39;)
                        break
                    else:
                        print(&#39;请输入正确的操作（输入“0”或“1”)&#39;)
            if panduan == &#39;步骤块&#39;:
                panduan_step = []
                steps, steps_name = daoru()
                xunhuan_yn = input(&#39;这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n&#39;)
                while 1:
                    if xunhuan_yn == &#39;yes&#39;:
                        panduan_step.append(&#39;步骤块&#39;)
                        panduan_step.append(&#39;循环&#39;)
                        panduan_step.append(steps_name)
                        panduan_step.append(steps)
                        panduans.append(panduan_step)
                        break
                    elif xunhuan_yn == &#39;no&#39;:
                        panduan_step.append(&#39;步骤块&#39;)
                        panduan_step.append(&#39;不循环&#39;)
                        panduan_step.append(steps_name)
                        panduan_step.append(steps)
                        panduans.append(panduan_step)
                        break
                    else:
                        xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
            if panduan == &#39;等待&#39;:
                panduan_if = []
                print(&#39;你选择了等待，程序将时刻检测目标位置的颜色以执行接下来的步骤块&#39;)
                panduan_if.append(&#39;等待&#39;)
                panduans.append(panduan_if)
            if panduan != &#39;步骤块&#39; and panduan != &#39;如果&#39; and panduan != &#39;等待&#39;:
                print(&#39;你的输入有误&#39;)
        if len(panduans) > 0:
            print(&#39;你一录入了至少一个逻辑判断，请选择继续选择目标位置的颜色来触发接下来你选择的步骤块&#39;)
            panduan_if = []
            while 1:
                click_dongzuo = input(&#39;请移动鼠标到目标位置上吸取颜色，输入“1”完成动作，输入“0”取消动作&#39;)
                if click_dongzuo == &#39;1&#39;:
                    xy = get_xy()
                    click_color = GetColor(xy)
                    panduan_yn = input(f&#39;这个位置的RGB为：{click_color}，是否确定为下一步骤块的判断根据？（输入"yes"or"no"）\n&#39;)
                    while 1:
                        if panduan_yn == &#39;yes&#39;:
                            get_caozuo_name()
                            print(f&#39;请选择满足当颜色为{click_color}时要执行的步骤包：&#39;)
                            steps, steps_name = daoru()
                            xunhuan_yn = input(&#39;这个步骤块是否循环执行直至条件触发？（输入"yes"or"no"）\n&#39;)
                            while 1:
                                if xunhuan_yn == &#39;yes&#39;:
                                    panduan_if.append(&#39;如果&#39;)
                                    panduan_if.append(xy)
                                    panduan_if.append(click_color)
                                    panduan_if.append(steps_name)
                                    panduan_if.append(&#39;循环&#39;)
                                    panduan_if.append(steps)
                                    panduans.append(panduan_if)
                                    print(&#39;添加成功，该步骤包将会循环&#39;)
                                    break
                                elif xunhuan_yn == &#39;no&#39;:
                                    panduan_if.append(&#39;如果&#39;)
                                    panduan_if.append(xy)
                                    panduan_if.append(click_color)
                                    panduan_if.append(steps_name)
                                    panduan_if.append(&#39;不循环&#39;)
                                    panduan_if.append(steps)
                                    panduans.append(panduan_if)
                                    print(&#39;添加成功，该步骤包将只执行一次&#39;)
                                    break
                                else:
                                    xunhuan_yn = input(&#39;你的输入有误，请输入"yes"or"no":&#39;)
                            tuichu = 1
                            break
                        if panduan_yn == &#39;no&#39;:
                            print(&#39;请重新选择&#39;)
                            break
                        else:
                            panduan_yn = input(&#39;你的输入有误，请输入"yes"or"no"&#39;)
                    if tuichu == 1:
                        break
                elif click_dongzuo == &#39;0&#39;:
                    print(&#39;操作已取消&#39;)
                    break
                else:
                    print(&#39;请输入正确的操作（输入“0”或“1”)&#39;)
    if choose == &#39;逻辑执行&#39;:
        print(&#39;这里是逻辑执行库，所有的逻辑判断都会存储到这里&#39;)
        print(panduans)
        xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(&#39;等待&#39;, &#39;1&#39;, &#39;循环&#39;))
        xiancheng.setDaemon(True)
        xiancheng.start()
        for pan in panduans:
            state = &#39;未触发&#39;
            if pan[0] == &#39;如果&#39;:
                print(pan[5])
                print(len(pan[5]))
                bu = str(pan[5])
                print(bu)
                bu = readListFromStr(bu)
                zhixing(bu)
                print(bu)
                if state == &#39;未触发&#39;:
                    if pan[4] == &#39;循环&#39;:
                        rgb = pan[2]
                        rgb_xy = pan[1]
                        _thread.start_new_thread(jianshi, ())
                        while 1:
                            if state == &#39;触发&#39;:
                                xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], &#39;循环&#39;))
                                xiancheng.start()
                                state = &#39;未触发&#39;
                                break
                    if pan[4] == &#39;不循环&#39;:
                        rgb = pan[2]
                        rgb_xy = pan[1]
                        _thread.start_new_thread(jianshi, ())
                        while 1:
                            if state == &#39;触发&#39;:
                                xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[3], pan[5], &#39;不循环&#39;))
                                xiancheng.start()
                                state = &#39;未触发&#39;
                                break
            if pan[0] == &#39;步骤块&#39;:
                stop_thread(xiancheng)
                if pan[1] == &#39;循环&#39;:
                    xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], &#39;循环&#39;))
                    xiancheng.start()
                if pan[1] == &#39;不循环&#39;:
                    xiancheng = threading.Thread(target=zhixingbuzhoukuai, args=(pan[2], pan[3], &#39;不循环&#39;))
                    xiancheng.start()
            if pan[0] == &#39;等待&#39;:
                print(&#39;程序正在监测目标位置RGB值&#39;)
        print(&#39;逻辑执行已全部执行完毕&#39;)
        break
    if choose == &#39;逻辑块存储&#39;:
        yorn = input("确定保存？\n输入&#39;yes&#39;or&#39;no&#39;\n")
        while 1:
            if yorn == &#39;yes&#39;:
                if len(panduans) == 0:
                    print(&#39;还未记录你任何操作，请添加操作再使用逻辑块存储功能&#39;)
                else:
                    do_name = input(&#39;请为以上操作命名吧：&#39;)
                    if &#39;逻辑块存储&#39; in do_name:
                        do_name = input(&#39;抱歉，你的命名里不允许包含”逻辑块存储“，请重新命名&#39;)
                    else:
                        path = r"{}逻辑块存储.txt".format(do_name)
                        listtotxt(list=panduans, path=path)
                break
            if yorn == &#39;no&#39;:
                print(&#39;你已取消存储&#39;)
                break
            else:
                yorn = input("请输入&#39;yes&#39;or&#39;no&#39;：\n")
    if choose == &#39;逻辑块导入&#39;:
        caozuojiyi = get_caozuokuai_name()
        while True:
            xunhuan_choose = input(&#39;已存储的操作有：{}\n请输入导入操作的操作名：&#39;.format(caozuojiyi))
            if xunhuan_choose in caozuojiyi:
                break
            else:
                print(&#39;逻辑块存储库中并无你想要的操作，请重新输入：&#39;)
        caozuopath = r"{}逻辑块存储.txt".format(xunhuan_choose)
        panduans = txttolist(path=caozuopath)
 
    if choose == 'q' or choose == 'quit' or choose == '退出' or choose == 'close':
        break
    if choose == 'tips' or choose == '提示' or choose == 'help' or choose == '帮助':
        print(
            '''你可以输入'点击', '右击', '中击', '逻辑执行', '判断', '滚动', '延时', '存储', '执行', '循环执行', '拖拽', '连点', '输入', '双击', '查看',
                      '导入', 'q', 'quit','退出', 'close', 'tips', '提示', 'help', '帮助', '按键'来帮助你完成你的自动化操作''')
    if not choose in ['点击', '右击', '中击', '逻辑执行', '判断', '滚动', '延时', '存储', '执行', '循环执行', '拖拽', '连点', '输入', '双击', '查看',
                      '导入', 'q', 'quit','退出', 'close', 'tips', '提示', 'help', '帮助', '按键']:
        print('你的输入有误或暂未开发此功能，请重新输入（输入”help“获得提示）')
print('代码已全部执行完毕,程序已退出')

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

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

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

    import pyttsx3
engine = pyttsx3.init()
engine.say(&#39;我抢到了!快来看一下&#39;)
engine.runAndWait()

    以上がPython を使用してカスタム ドット コネクタを実装する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

    声明：
    この記事はyisu.comで複製されています。侵害がある場合は、admin@php.cn までご連絡ください。
    前の記事：Pythonファイル処理方法サンプルコード解析次の記事：Pythonファイル処理方法サンプルコード解析

    関連記事

    続きを見る