利用os模块平日里写的一些脚本（后续偶尔更新）

自动获取本机ip地址的脚本：

import os
import re


def get_ip():
    result = os.popen('ipconfig').read()
    pattern = re.compile(r'((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})(.((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})){3}')
    ip = pattern.search(result).group()
    print("获取到本机IP地址是：{}".format(ip))
    os.system("pause")


get_ip()

安装apk的脚本：

import os
import time

def install_app(apk_path):
    '''
    :param apk_path:APP安装包路径
    :return:
    '''
    print("开始执行")
    driver_exist = os.popen("adb devices").read()
    print(driver_exist)
    new_str = driver_exist.split("
")
    new_list = [x for x in new_str if x != '']  # 去掉空''
    try:
        driver_name = new_list[1][0:16]  # 取出设备名
        if len(driver_name) == 16:
            install_result = os.popen('adb install "{}"'.format(apk_path)).read()
            if "Success" in install_result:
                print("安装成功")
            else:
                print("安装失败")
    except Exception as e:
        print("设备名未获取到{}".format(e))
        raise e
    finally:
        os.system('adb kill-server')
        os.system("pause")
        os._exit(0)



install_app("D:\Download\Chrome Download\app-release-demo (2).apk")

启动django服务的脚本：

import os

def run_server(work_directory=r"D:SoftwarePycharmWorkspaceMyDjango",order = "python manage.py runserver 0.0.0.0:8000"):
    '''

    :param work_directory:切换工作目录
    :param order:需要执行的命令
    :return:
    '''
    print(os.getcwd())      # todo 获取当前目录
    os.chdir(work_directory)  # TODO 切换目录
    print(os.getcwd())
    os.system(order)

if __name__ == '__main__':
    run_server()

打开scrcpy投屏软件自动投屏的脚本（前提条件：处于同一局域网内）：

'''该脚本主要实现自动执行adb命令，打开scrcpy投屏软件的功能'''
import os


def execute_order(cmd='taskkill /IM adb.exe -f', order1='adb tcpip 5555', order2='adb connect 192.168.1.112:5555',
                  procedure_path=r'D:SoftwareScrcpyscrcpy-win64scrcpy.exe'):
    '''
    cmd:填写杀掉进程的命令
    order1和order2:填写adb命令
    procedure_path:填写程序路径
    '''
    os.system(cmd)
    os.system(order1)
    os.system(order2)
    scrcpy = procedure_path
    os.execl(scrcpy, 'scrcpy.exe')


if __name__ == '__main__':
    execute_order()

自动获取手机ip地址投屏的脚本（需接入usb才能自动获取）：

'''实现自动获取ip，投屏的功能'''

import os
import re

os.system('adb disconnect ')
os.system('taskkill /im scrcpy.exe -f')
os.system('taskkill /IM adb.exe -f')
try:
    res = os.popen('adb shell "ip addr | grep global"').read()
    pattern = re.compile(r'((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})(.((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})){3}')
    ip = pattern.search(res).group()
    print(ip)
except Exception as e:
    print("ip获取失败{}".format(e))
os.system('adb tcpip 5555')
os.system('adb connect {}:5555'.format(ip))
print('adb connect {}:5555'.format(ip))
procedure_path = r'D:SoftwareScrcpyscrcpy-win64scrcpy.exe'
scrcpy = procedure_path
os.execl(scrcpy, 'scrcpy.exe')

 删除某个目录下所有文件的脚本：

import os


def delect_file(folder_path):
    print("准备删除{}目录下的文件...".format(folder_path))
    folder_is_null = os.listdir(folder_path)
    if folder_is_null:             # todo 判断文件夹是否为空，为空就不执行了
        for i in os.listdir(folder_path):  # todo os.listdir(folder_path)#返回一个列表，里面是当前目录下面的所有东西的相对路径
            file_data = folder_path + "\" + i
            if os.path.isfile(file_data) == True:
                os.remove(file_data)
            else:
                delect_file(file_data)
        print("总共删除{}个文件...".format(len(folder_is_null)))
        os.system("pause")
        os._exit(0)
    else:
        print("当前文件夹是空的")
        os.system("pause")
        os._exit(0)

delect_file(r"C:UsersadminDesktopScreenshotcode")

 批量获取token：

import requests

url = "http://49.235.92.12:9000/api/v1/login"
for i in range(1,11):
    username = "test"+str(i)
    json = {
        "username":username,
        "password":123456
    }
    res = requests.post(url,json)
    print(res.json())
    token = res.json()["token"]
    with open("token_data","a+") as f:
        f.write(username+","+token+"
")

 将视频按固定帧率分解成一帧帧的图片：

# TODO 该脚本主要实现将视频按固定帧率分解成一帧帧的图片
import os, sys
import threading


def split_video(video_path):
    '''

    :param video_path: 视频的绝对路径，建议先将要切割的视频拖到cmd窗口，然后再复制路径当做参数传递，否则会产生OSError错误
    :return:
    '''

    print("开始执行{}目录下的操作：".format(video_path))

    split_file = os.path.split(video_path)  # 分割文件名与目录
    print(split_file)

    split_filename = os.path.splitext(split_file[1])  # 分离文件名和扩展名
    print(split_filename)

    os.chdir(split_file[0])  # 切换目录

    try:
        touch_dir = os.mkdir(split_filename[0])  # 创建文件夹，
    except Exception as e:
        print("文件已存在,请检查文件目录")
        os.system("pause")
        raise e

    os.chdir(split_filename[0])  # 切换目录至新建文件夹里面

    print("切割后的图片保存到：{}".format(os.getcwd()))
    os.popen("ffmpeg -i {} -r 60 %d.jpg".format(video_path)).read()


def run(path_list):
    for path in path_list:
        t1 = threading.Thread(target=split_video, args=(path,))
        t1.start()
        t1.join()


if __name__ == '__main__':
    path_list = (r"D:Video1.mp4",r"D:Video20200516_132923.mp4")
    run(path_list)
    print("视频分解完成。。。")
    os.system("pause")
    os._exit(0)

 获取linux系统的ip:

import paramiko
import re


class GetLinuxIp():
    '''获取linux服务器ip'''

    def __init__(self, ip, port, user, password, cmds):
        '''

        :param ip: linux主机的ip
        :param port: linux主机的端口
        :param user: linux主机登录用户名
        :param password: linux主机登录密码
        :param cmds: linux命令列表，传list类型
        '''
        self.ip = ip
        self.port = port
        self.user = user
        self.password = password
        self.cmds = cmds
        try:
            self.ssh = paramiko.SSHClient()
            self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            self.ssh.connect(self.ip, self.port, self.user, self.password, timeout=10)
            print("连接成功...")
        except Exception as e:
            # raise e
            print("连接失败，错误是{}".format(e))
            raise e

    def excute_command(self):
        '''执行命令'''
        for i in self.cmds:
            self.stdin, self.stdout, self.stderr = self.ssh.exec_command(i)

    def get_result(self):
        '''获取结果'''
        result = self.stdout.read().decode()
        pattern = re.compile(r'((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})(.((2(5[0-5]|[0-4]d))|[0-1]?d{1,2})){3}')
        self.ip = pattern.search(result).group()
        print("获取到linux服务器的ip是：{}".format(self.ip))

    def __del__(self):
        '''关闭连接'''
        self.ssh.close()
        print("连接关闭...")


if __name__ == '__main__':
    linux = GetLinuxIp("121.196.120.113", 22, "root", "123_Xiaohaikun", ["ifconfig"])
    linux.excute_command()
    linux.get_result()

 添加游戏后自动审核通过：

import requests
import pymysql
import os


class AuditPass():
    def __init__(self, user_id):
        '''
        :param user_id: Profile页面的用户ID
        '''
        self.user_id = user_id
        # 连接初始化
        self.conn = pymysql.connect(host='47.254.187.156', port=3306, user='egirl_EN',
                                    password='Y18uy1Fw8HBpYtHmqGSEyd0ipDAYUWv9u0', database='egirl')
        self.cursor = self.conn.cursor()

    def get_login_token(self):
        '''获取用户toekn'''
        login_url = "https://test-play.gamesegirl.com/web/login/for-sys"
        param = {"account": "EpaAdmin",
                 "password": "123456"}
        headers = {
            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36",
            "content-type": "application/json",
            "referer": "https://admin.gamesegirl.com/user/login"}
        try:
            res = requests.post(url=login_url, json=param, headers=headers)
            self.token = res.json()["content"]["token"]
        except Exception as e:
            print("错误是:{}".format(e))

    def query_productId(self):
        '''查询数据库productId'''
        # SQL查询产品ID
        sql = "SELECT MAX(t_product.id) FROM t_product WHERE t_product.user_id = {}".format(
            self.user_id)
        try:
            self.cursor.execute(sql)
            for temp in self.cursor.fetchone():
                self.productId = temp

        except Exception as e:
            # 如果发生错误则回滚
            self.conn.rollback()
            raise e

    def audit_list(self):
        '''通过接口游戏自动审核通过'''
        url = "https://test-play.gamesegirl.com/admin/audit/audit"
        param = {"productId": self.productId,
                 "auditStatus": 1,
                 "auditRemark": "",
                 "pageAuditStatus": "0,3"}
        headers = {
            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36",
            "content-type": "application/json",
            "_tk_": self.token}
        try:
            res = requests.post(url, json=param, headers=headers)
        except Exception as e:
            print("错误是:{}".format(e))
        else:
            print(res.text)
            print("审核通过")

    def __del__(self):
        '''关闭连接资源'''
        self.cursor.close()
        self.conn.close()


if __name__ == '__main__':
    audit = AuditPass("2397")
    audit.get_login_token()
    audit.query_productId()
    audit.audit_list()
    os.system("pause")

 手机号自动注册：

'''该脚本主要实现手机号自动注册的功能'''
import requests
import pymysql
import time
import random
import os


class AutoRegister():
    def __init__(self, pwd="Epal123"):
        self.pwd = pwd
        self.conn = pymysql.connect(host='47.254.87.156', port=3306, user='egirl_EN',
                                    password='Y18uy1Fw8HBpYtHmqGSEyd0ipDAYUWv9u0', database='egirl')
        self.cursor = self.conn.cursor()

    def generate_phone(self):
        '''生成手机号'''
        prelist = ["130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "147", "150", "151", "152",
                   "153", "155", "156", "157", "158", "159", "173", "186", "187", "188"]
        self.phone_number = random.choice(prelist) + "".join(random.choice("0123456789") for i in range(8))
        # print(self.phone_number)

    def generate_date(self):
        '''生成时间，解决用户注册小于13岁的问题'''
        a1 = (1976, 1, 1, 0, 0, 0, 0, 0, 0)  # 开始日期时间元组（1976-01-01 00：00：00）
        a2 = (2006, 12, 31, 23, 59, 59, 0, 0, 0)  # 结束日期时间元组（2006-12-31 23：59：59）
        start = time.mktime(a1)
        end = time.mktime(a2)
        t = random.randint(start, end)
        date_touple = time.localtime(t)  # 将时间戳生成时间元组
        self.date = time.strftime("%Y-%m-%d", date_touple)  # 将时间元组转成格式化字符串如（2002-05-21）
        # print(self.date)

    def register_phone_number(self):
        '''注册手机号'''
        register_url = "https://test-play.gamesegirl.com/user/register/send_verification_code"
        param = {"mobile": "+86{}".format(self.phone_number),
                 "birthDay": "{}".format(self.date),
                 "registerType": "MOBILE"
                 }
        try:
            result = requests.post(url=register_url, json=param)
        except Exception as e:
            print("错误是:{}".format(e))
            raise e

    def query_verify_code(self):
        '''查询验证码'''
        sql = "SELECT JSON_EXTRACT(extra, '$.verificationCode') FROM sms_record WHERE mobile LIKE '%{}%' ORDER BY id DESC LIMIT 1".format(
            str(self.phone_number))
        self.cursor.execute(sql)
        try:
            for temp in self.cursor.fetchone():
                self.verify_code = temp
        except Exception as e:
            # 如果发生错误则回滚
            self.conn.rollback()
            raise e

    def input_verify_code(self):
        '''输入验证码'''
        input_code_url = "https://test-play.gamesegirl.com/app/user/register/by_password"
        param = {
            "mobile": "+86{}".format(self.phone_number),
            "password": self.pwd,
            "verificationCode": int(eval(self.verify_code)),
            "appClient": "EPAL_IOS",
            "countryCallingCode": "+86",
            "areaRegion": "CN",
            "registerType": "MOBILE",
            "birthDay": "{}".format(self.date)
        }
        try:
            res = requests.post(url=input_code_url, json=param)
            token = res.json()["content"]
        except Exception as e:
            print("错误是:{}".format(e))
            raise e
        else:
            if token != "null":
                print("注册手机号是：{}".format(self.phone_number))
                print("注册账号密码是：{}".format(self.pwd))
            else:
                print("注册失败")

    def __del__(self):
        '''关闭连接资源'''
        self.cursor.close()
        self.conn.close()


def run_time(func):
    '''装饰器检测代码运行时间'''
    def end_time(*args):
        start_time = time.time()
        func(*args)
        stop_time = time.time()
        total_time = stop_time - start_time
        print('代码运行时间共耗时:{}'.format(total_time))

    return end_time


@run_time
def run():
    register = AutoRegister()
    register.generate_phone()
    register.generate_date()
    register.register_phone_number()
    register.query_verify_code()
    register.input_verify_code()


if __name__ == '__main__':
    run()
    os.system("pause")

 修改商家等级：

'''该脚本主要用来修改商家等级'''
import pymysql
import os


class UpdataMerchantLevel():
    def __init__(self, merchant_level, user_id):
        '''

        :param merchant_level: 想修改的商家等级:EPAL2,EPAL3,ESTAR1,ESTAR2
        :param user_id: 用户user_id
        '''
        self.user_id = user_id
        self.merchant_level = merchant_level
        self.conn = pymysql.connect(host='47.254.87.156', port=3306, user='egirl_EN',
                                    password='Y18uy1Fw8HBpYtHmqGSEyd0ipDAYUWv9u0', database='egirl')
        self.cursor = self.conn.cursor()

    def change_merchant_level(self):
        '''修改商家等级'''
        sql1 = "select merchant_level from t_user u left join t_user_ext ue on ue.user_id = u.id where u.id='{}'".format(
            self.user_id)
        sql2 = "UPDATE t_user_ext SET merchant_level='{}' WHERE user_id='{}'".format(self.merchant_level, self.user_id)

        try:
            # 1.先查询原有等级
            self.cursor.execute(sql1)
            self.conn.commit()
            for temp in self.cursor.fetchone():
                origin_level = temp
            # 2.执行更新等级的sql
            self.cursor.execute(sql2)
            self.conn.commit()
            # 3.查询最终等级
            self.cursor.execute(sql1)
            self.conn.commit()
            for temp in self.cursor.fetchone():
                final_level = temp

        except:
            self.conn.rollback()
        else:
            print("修改前的等级是{}".format(origin_level))
            print("修改后的等级是{}".format(final_level))

        finally:
            self.cursor.close()
            self.conn.close()


def run():
    up = UpdataMerchantLevel('EPAL2', '2397')
    up.change_merchant_level()


if __name__ == '__main__':
    run()
    os.system("pause")

 创建文本文件：

import time


def create_text(path=r"D:Program Files (x86)SublimeSublime Text3File\"):
    """
    创建txt文本文件
    :param path: 文件路径
    :return:
    """
    filename = time.strftime("%Y-%m-%d").replace("-", "")
    file_path = path + filename + '.txt'
    with open(file_path, 'w') as f:
        f.write('')


if __name__ == '__main__':
    create_text()

 python三元运算写法：

import requests
import time
import os



def del_login_limit(account="1489088761@qq.com"):
    """
    解决“The number of retries has been exceeded, please try again in 24 hour”问题
    :param account: 需要删除的邮箱号
    :return:
    """
    requests.packages.urllib3.disable_warnings()
    current_date = time.strftime("%Y-%m-%d").replace("-", "")
    url = "https://test-play.gamesegirl.com/mock/del_cache"
    data = {
        "key": "LEIJ34-L3RQ09-E3ORIJFAL-EORALFA",
        "redisKey": "1001:test:{}:loginAndRegister:login4Email:{}".format(current_date, account)
    }
    response = requests.post(url, json=data, verify=False)
    print(response.json()) if response.status_code == 200 else print("请求失败")


if __name__ == '__main__':
    del_login_limit()
    os.system("pause")

 操作redis数据库：

import redis


class OperateRedis(object):
    def __init__(self):
        self.host = "47.254.87.156"
        self.port = "6379"
        self.pwd = "E1Ql/NlOA2X#Oq85p6zOFC2C93MJCjATO1"
        self.pool = redis.ConnectionPool(host=self.host, port=self.port, password=self.pwd, decode_responses=True)
        self.connect = redis.Redis(connection_pool=self.pool)

    def query_email_verify_code(self, email_account):
        """

        :param email_account: 邮箱账号
        :return:
        """
        result = self.connect.get("egirl:email:validate:{}:REGISTER".format(email_account))
        print(result)


if __name__ == '__main__':
    op = OperateRedis()
    op.query_email_verify_code("jldvwc82356@chacuo.net")

 操作redis优化版本：先判断键是否存在，如果存在再去查询。

import redis


class OperateRedis(object):
    def __init__(self):
        self.host = "47.254.87.156"
        self.port = "6379"
        self.pwd = "E1Ql/NlOA2X#Oq85p6zOFC2C93MJCjATO1"
        self.pool = redis.ConnectionPool(host=self.host, port=self.port, password=self.pwd, decode_responses=True)
        self.connect = redis.Redis(connection_pool=self.pool)

    def query_email_verify_code(self, email_account):
        """

        :param email_account: 邮箱账号
        :return:
        """
        result = self.connect.get("egirl:email:validate:{}:REGISTER".format(email_account)) 
            if self.connect.exists("egirl:email:validate:{}:REGISTER".format(email_account)) == 1 else print("键不存在")
        print("获取到的邮箱验证码是：{}".format(result))


if __name__ == '__main__':
    op = OperateRedis()
    op.query_email_verify_code("jldvwc82356@chacuo.net")

 判断user_id是否重复：

import requests


def func(loop_count=80):
    count_ = 0
    while count_ < loop_count:
        url = 'https://test-community.gamesegirl.com/user/meets/match'
        data = {"limit": 30,
                "likeUserIds": [],
                "dislikeUserIds": [],
                "excludeUserIds": []}
        user_id_list = [3165, 2924, 3184, 3232, 4, 3216, 3240, 3163, 3291, 18, 3217, 3, 2702, 3161, 2636]
        response = requests.post(url=url, json=data).json()
        response_length = len(response['content'])
        count_ += 1
        for i in range(response_length):
            userid = response['content'][i]['userId']
            if userid not in user_id_list:
                print("ID：{}不在列表里面".format(userid))
                print("第{}次请求出错".format(count_))
                return
            else:
                print("第{}次请求正常".format(count_))


if __name__ == '__main__':
    func()

 注册代码：

import requests
import redis
import random
import pymysql
import time
import os
from faker import Faker
import re


class RegisterEmail(object):
    def __init__(self, email_=None, pwd="Epal123"):
        self.email = None
        self.tk = None
        self.user_id = None
        self.sex = None
        self.appClient = None
        self.pwd = pwd
        self.faker = Faker()
        self.nickname = self.faker.name()
        self.redis_deploy = {
            "host": "47.254.87.156",
            "port": "6379",
            "password": "E1Ql/NlOA2X#Oq85p6zOFC2C93MJCjATO1",
            "decode_responses": "True"
        }
        self.mysql_deploy = {
            "host": "47.254.87.156",
            "port": 3306,
            "user": "egirl_EN",
            "password": "Y18uy1Fw8HBpYtHmqGSEyd0ipDAYUWv9u0",
            "database": "egirl"
        }
        self.host = "https://test-play.gamesegirl.com/"
        self.url_dict = {
            "verify_code_url": "v3/user/register/send_verification_code",
            "by_password_url": "app/user/register/by_password",
            "login_by_password": "app/user/login/by_password",
            "edit_url": "web/user/edit"
        }
        self.pool = redis.ConnectionPool(**self.redis_deploy)
        self.connect = redis.Redis(connection_pool=self.pool)
        self.conn = pymysql.connect(**self.mysql_deploy)
        self.cursor = self.conn.cursor()
        if email_ is None:
            self.email = "".join(random.choice("0123456789") for i in range(6)) + random.choice(["@163.com", "@qq.com"])
        else:
            pattern = r"^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(.[a-zA-Z0-9-]+)*.[a-zA-Z0-9]{2,6}$"
            if re.match(pattern, email_):
                self.email = email_
            else:
                print(f"邮箱格式错误，请检查输入{email_}")

    def register_email(self):
        """注册账号"""
        verify_code_url = self.host + self.url_dict.get("verify_code_url")
        data1 = {"email_": "{}".format(self.email),
                 "password": self.pwd,
                 "birthday": "1997-01-01",
                 "emailPushEnabled": False,
                 "registerType": "EMAIL"}
        response1 = requests.post(url=verify_code_url, json=data1).json()
        if response1["status"] == "OK":
            if self.connect.exists("1001:test:verificationCode:email:{}:EMAIL_BIZ_CODE_REGISTER_VERIFICATION_CODE"
                                   "".format(self.email)) == 1:
                verify_code = self.connect.get(
                    "1001:test:verificationCode:email:{}:EMAIL_BIZ_CODE_REGISTER_VERIFICATION_CODE".format(self.email))
                by_password_url = self.host + self.url_dict.get("by_password_url")
                data2 = {
                    "verificationCode": "{}".format(verify_code),
                    "password": self.pwd,
                    "birthdayVisibleEnabled": False,
                    "appClient": "EPAL_IOS",
                    "emailPushEnabled": False,
                    "email_": self.email,
                    "registerType": "EMAIL",
                    "birthDay": "2000-01-01"
                }
                response2 = requests.post(by_password_url, json=data2).json()
                if response2["status"] == "OK":
                    sql = "SELECT id FROM egirl.t_user WHERE email='{}'".format(self.email)
                    self.cursor.execute(sql)
                    self.user_id = [i for i in self.cursor.fetchone()][0]
                    if self.user_id:
                        print("注册邮箱是：{}".format(self.email))
                        print("注册邮箱密码是：{}".format(self.pwd))
                        print("注册邮箱的User_Id是：{}".format(self.user_id))
                    return print("查询数据库，注册失败")
                return print("请求{}接口失败".format(by_password_url))
            return print('键为空')
        return print("请求{}接口失败".format(verify_code_url))

    def edit_user_info(self):
        """编辑基本信息"""
        by_password = self.host + self.url_dict.get("login_by_password")
        app_Client_list = ["EPAL_ANDROID", "EPAL_IOS"]
        self.appClient = random.choice(app_Client_list)
        data = {
            "appClient": self.appClient,
            "loginKey": self.email,
            "password": self.pwd
        }
        login_response = requests.post(url=by_password, json=data).json()
        if login_response['status'] == "OK" and login_response['content'] is not None:
            self.tk = login_response['content']
            edit_url = self.host + self.url_dict.get("edit_url")
            headers = {"_tk_": self.tk}
            sex_list = [0, 1, 2]
            self.sex = random.choice(sex_list)
            data = {"nickname": self.nickname,
                    "sex": self.sex,
                    "birthday": "2000-01-01"}
            response = requests.post(url=edit_url, json=data, headers=headers).json()
            if response['content']['userId'] == self.user_id and response['content']['nickname'] == self.nickname and 
                    response['content']['sex'] == self.sex:
                print(f"注册邮箱的nickname是：{self.nickname}")
                sex_dict = {
                    "0": "男",
                    "1": "女",
                    "2": "中性",
                }
                print("注册邮箱性别是：{}".format(sex_dict.get(str(self.sex))))
                # if self.sex == 0:
                #     print("注册邮箱性别是：男")
                # elif self.sex == 1:
                #     print("注册邮箱性别是：女")
                # else:
                #     print("注册邮箱性别是：中性的")
        return print("登录失败")

    def __del__(self):
        self.cursor.close()
        self.conn.close()


def retry(loop_num=2, wait_time=1):
    """
    :param loop_num: 循环次数，默认2次
    :param wait_time: 等待时间，默认1s
    :return:
    """

    def wrapper(func):
        def _wrapper(*args, **kwargs):
            raise_ex = 0
            for i in range(1, loop_num + 1):
                print(f"第{i}次操作")
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    time.sleep(wait_time)
                    raise_ex += 1
                    if raise_ex == loop_num:
                        raise e

        return _wrapper

    return wrapper


@retry()
def run():
    RE = RegisterEmail("hkxoqn751241@chaccuo.net")
    RE.register_email()
    RE.edit_user_info()


if __name__ == '__main__':
    run()
    # os.system("pause")

 优化注册代码：

import requests
import redis
import random
import pymysql
import time
import os
import yaml
import io


class UserName(object):
    yaml.warnings({'YAMLLoadWarning': False})

    def __init__(self, loop_num, prefix_name, path_=None):
        """
        :param loop_num: 循环次数
        :param prefix_name: 前缀名称,如传"Knight",就生成Knight1,Knight2...
        :param path_: 配置文件路径,可以不传，不传默认在工程目录下生成username.yml文件
        """
        self.loop_num = loop_num
        self.prefix_name = prefix_name
        self.path = None
        if path_ is None:
            self.path = os.getcwd() + '\username.yml'
        else:
            self.path = path_

    def write_yml(self, num=0):
        data = {'num': num}
        with io.open(self.path, 'w', encoding="utf-8") as wf:
            yaml.dump(data, wf)

    def read_yml(self):
        with io.open(self.path, 'r', encoding="utf-8") as rf:
            yml_data = yaml.load(rf)
            return yml_data.get('num', 0)

    def add_user_name(self):
        """原有基础上添加用户名称"""
        start_value = self.read_yml()
        num = start_value
        name_list = []
        for i in range(start_value, self.loop_num + start_value):
            # print(f"{self.prefix_name}{i}")
            num += 1
            name_list.append(f"{self.prefix_name}{i}")
        self.write_yml(num)
        return name_list

    def create_user_name(self):
        """创建用户名称"""
        self.write_yml()
        start_value = self.read_yml()
        num = start_value
        name_list = []
        for i in range(start_value, self.loop_num + start_value):
            # print(f"{self.prefix_name}{i}")
            num += 1
            name_list.append(f"{self.prefix_name}{i}")
        self.write_yml(num)
        return name_list

    def run(self):
        return self.add_user_name() if os.path.isfile(self.path) else self.create_user_name()


class RegisterEmail(object):
    def __init__(self, email_, pwd="Epal123"):
        self.email = email_
        self.pwd = pwd
        self.tk = None
        self.user_id = None
        self.sex = None
        self.appClient = None
        name = UserName(1, "Between")
        self.nickname = name.run()[0]
        self.redis_deploy = {
            "host": "47.254.87.156",
            "port": "6379",
            "password": "E1Ql/NlOA2X#Oq85p6zOFC2C93MJCjATO1",
            "decode_responses": "True"
        }
        self.mysql_deploy = {
            "host": "47.254.87.156",
            "port": 3306,
            "user": "egirl_EN",
            "password": "Y18uy1Fw8HBpYtHmqGSEyd0ipDAYUWv9u0",
            "database": "egirl"
        }
        self.pool = redis.ConnectionPool(**self.redis_deploy)
        self.connect = redis.Redis(connection_pool=self.pool)
        self.conn = pymysql.connect(**self.mysql_deploy)
        self.cursor = self.conn.cursor()

    def register_email(self):
        """注册账号"""
        verify_code_url = "https://test-play.gamesegirl.com/v3/user/register/send_verification_code"
        data1 = {"email_": "{}".format(self.email),
                 "password": self.pwd,
                 "birthday": "1997-01-01",
                 "emailPushEnabled": False,
                 "registerType": "EMAIL"}
        response1 = requests.post(url=verify_code_url, json=data1).json()
        if response1["status"] == "OK":
            if self.connect.exists("1001:test:verificationCode:email:{}:EMAIL_BIZ_CODE_REGISTER_VERIFICATION_CODE"
                                   "".format(self.email)) == 1:
                verify_code = self.connect.get(
                    "1001:test:verificationCode:email:{}:EMAIL_BIZ_CODE_REGISTER_VERIFICATION_CODE".format(self.email))
                by_password_url = "https://test-play.gamesegirl.com/app/user/register/by_password"
                data2 = {
                    "verificationCode": "{}".format(verify_code),
                    "password": self.pwd,
                    "birthdayVisibleEnabled": False,
                    "appClient": "EPAL_IOS",
                    "emailPushEnabled": False,
                    "email_": self.email,
                    "registerType": "EMAIL",
                    "birthDay": "2000-01-01"
                }
                response2 = requests.post(by_password_url, json=data2).json()
                if response2["status"] == "OK":
                    sql = "SELECT id FROM egirl.t_user WHERE email='{}'".format(self.email)
                    self.cursor.execute(sql)
                    self.user_id = [i for i in self.cursor.fetchone()][0]
                    if self.user_id:
                        print("注册邮箱是：{}".format(self.email))
                        print("注册邮箱密码是：{}".format(self.pwd))
                        print("注册邮箱的User_Id是：{}".format(self.user_id))
                    else:
                        print("查询数据库，注册失败")
                else:
                    print("请求{}接口失败".format(by_password_url))
            else:
                print('键为空')
        else:
            print("请求{}接口失败".format(verify_code_url))

    def edit_user_info(self):
        """编辑基本信息"""
        by_password = "https://test-play.gamesegirl.com/app/user/login/by_password"
        app_Client_list = ["EPAL_ANDROID", "EPAL_IOS"]
        self.appClient = random.choice(app_Client_list)
        data = {
            "appClient": self.appClient,
            "loginKey": self.email,
            "password": self.pwd
        }
        login_response = requests.post(url=by_password, json=data).json()
        if login_response['status'] == "OK" and login_response['content'] is not None:
            self.tk = login_response['content']
            edit_url = "https://test-play.gamesegirl.com/web/user/edit"
            headers = {"_tk_": self.tk}
            sex_list = [0, 1, 2]
            self.sex = random.choice(sex_list)
            data = {"nickname": self.nickname,
                    "sex": self.sex,
                    "birthday": "2000-01-01"}
            response = requests.post(url=edit_url, json=data, headers=headers).json()
            if response['content']['userId'] == self.user_id and response['content']['nickname'] == self.nickname and 
                    response['content']['sex'] == self.sex:
                print(f"注册邮箱的nickname是：{self.nickname}")
                sex_dict = {
                    "0": "男",
                    "1": "女",
                    "2": "中性",
                }
                print("注册邮箱性别是：{}".format(sex_dict.get(str(self.sex))))
        else:
            print("登录失败")

    def __del__(self):
        self.cursor.close()
        self.conn.close()


def retry(loop_num=2, wait_time=1):
    """
    :param loop_num: 循环次数，默认2次
    :param wait_time: 等待时间，默认1s
    :return:
    """

    def wrapper(func):
        def _wrapper(*args, **kwargs):
            raise_ex = 0
            for i in range(1, loop_num + 1):
                print(f"第{i}次操作")
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    time.sleep(wait_time)
                    raise_ex += 1
                    if raise_ex == loop_num:
                        raise e

        return _wrapper

    return wrapper


@retry()
def run(number=1):
    for i in range(number):
        email = "".join(random.choice("0123456789") for i in range(6)) + random.choice(["@163.com", "@qq.com"])
        re = RegisterEmail(email)
        re.register_email()
        re.edit_user_info()


if __name__ == '__main__':
    run(1)
    os.system("pause")

 录屏脚本：

from PIL import ImageGrab
import numpy as np
import cv2
import datetime
from pynput import keyboard
import threading
import os

flag = False  # 停止标志位


def video_record():
    """
    屏幕录制！
    :return:
    """
    name = datetime.datetime.now().strftime('%Y-%m-%d %H-%M-%S')  # 当前的时间
    p = ImageGrab.grab()  # 获得当前屏幕
    a, b = p.size  # 获得当前屏幕的大小
    fourcc = cv2.VideoWriter_fourcc(*'XVID')  # 编码格式
    video = cv2.VideoWriter('%s.avi' % name, fourcc, 20, (a, b))  # 输出文件命名为test.mp4,帧率为16，可以自己设置
    print("开始录制，结束请按Esc键")
    while True:
        im = ImageGrab.grab()
        imm = cv2.cvtColor(np.array(im), cv2.COLOR_RGB2BGR)  # 转为opencv的BGR格式
        video.write(imm)
        if flag:
            print("录制结束！")
            break
    video.release()


def on_press(key):
    """
    键盘监听事件！！！
    :param key:
    :return:
    """
    # print(key)
    global flag
    if key == keyboard.Key.esc:
        flag = True
        print("stop monitor！")
        return False  # 返回False，键盘监听结束！


if __name__ == '__main__':
    th = threading.Thread(target=video_record)
    th.start()
    with keyboard.Listener(on_press=on_press) as listener:
        listener.join()
    os.system("pause")