import time, random, string, ctypes, re


def 延迟(毫秒):
    """
    # 示例用法
    延迟(500)
    """
    time.sleep(毫秒 / 1000)


def 文本_到大写(要转换的文本):
    """
    将文本转换为大写。

    参数:
        要转换的文本 (str): 要转换为大写的文本。

    返回:
        str: 转换为大写的文本。如果转换失败或出现任何异常，则返回 False。

    示例:
        文本 = "Hello world"
        结果 = 文本_到大写(文本)
        print(结果)  # 输出：HELLO WORLD
    """
    try:
        大写文本 = 要转换的文本.upper()
        return 大写文本
    except Exception:  # 捕获所有异常
        return False


def 文本_到小写(要转换的文本):
    """
    将文本转换为小写。

    参数:
        要转换的文本 (str): 要转换为小写的文本。

    返回:
        str: 转换为小写的文本。如果转换失败或出现任何异常，则返回 False。

    示例:
        文本 = "Hello World"
        结果 = 文本_到小写(文本)
        print(结果)  # 输出：hello world
    """
    try:
        小写文本 = 要转换的文本.lower()
        return 小写文本
    except Exception:  # 捕获所有异常
        return False


def 文本_颠倒(欲转换文本, 带有中文=False):
    """
    将文本颠倒过来。

    参数:
        欲转换文本 (str): 欲颠倒的文本。
        带有中文 (bool): 如果为 True，则假定文本中包含中文字符。

    返回:
        str: 颠倒后的文本。如果转换失败或出现任何异常，则返回 False。

    示例:
        文本 = "123456"
        结果 = 文本_颠倒(文本)
        print(结果)  # 输出：654321
    """
    try:
        if 带有中文:
            return 欲转换文本[::-1]
        else:
            # 如果文本中含有中文字符，直接使用[::-1]可能会出现乱序，所以先转换为列表再逆序
            文本列表 = list(欲转换文本)
            文本列表.reverse()
            return ''.join(文本列表)
    except Exception:  # 捕获所有异常
        return False


def 文本_分割文本(待分割文本, 分隔符):
    """
    将文本按照指定分隔符分割。

    参数:
        待分割文本 (str): 要分割的文本。
        分隔符 (str): 分隔文本的字符串。

    返回:
        list: 分割后的文本列表。如果转换失败或出现任何异常，则返回 False。

    示例:
        文本 = "apple,orange,banana"
        分隔符 = ","
        分割结果 = 文本_分割文本(文本, 分隔符)
        print("分割结果:", 分割结果)
    """
    try:
        return 待分割文本.split(分隔符)
    except Exception:  # 捕获所有异常
        return False


def 文本_加密(参数_待加密文本, 参数_加密的密码):
    """
    加密文本。

    参数:
        参数_待加密文本 (str): 待加密的文本。
        参数_加密的密码 (str): 加密的密码，建议使用5位以上的数字。

    返回:
        str: 加密后的文本。如果密码长度不足或出现任何异常，则返回空字符串。

    示例:
        待加密文本 = "hello"
        加密的密码 = "12345"
        加密后文本 = 文本_加密(待加密文本, 加密的密码)
        print("加密后文本:", 加密后文本)
    """
    try:
        if len(参数_加密的密码) < 5:  # 密码建议使用5位以上的数字
            return ""  # 密码长度不足，加密失败，返回空文本

        加密结果 = ""
        for i, 字符 in enumerate(参数_待加密文本):
            加密后字符 = chr(ord(字符) + int(参数_加密的密码[i % len(参数_加密的密码)]))
            加密结果 += 加密后字符
        return 加密结果
    except Exception:  # 捕获所有异常
        return ""


def 文本_解密(参数_待解密文本, 参数_解密的密码):
    """
    解密文本。

    参数:
        参数_待解密文本 (str): 待解密的文本。
        参数_解密的密码 (str): 解密的密码，建议使用5位以上的数字。

    返回:
        str: 解密后的文本。如果密码长度不足或出现任何异常，则返回空字符串。

    示例:
        待解密文本 = "igopt"
        解密的密码 = "12345"
        解密后文本 = 文本_解密(待解密文本, 解密的密码)
        print("解密后文本:", 解密后文本)
    """
    try:
        if len(参数_解密的密码) < 5:  # 密码建议使用5位以上的数字
            return ""  # 密码长度不足，解密失败，返回空文本

        解密结果 = ""
        for i, 字符 in enumerate(参数_待解密文本):
            解密后字符 = chr(ord(字符) - int(参数_解密的密码[i % len(参数_解密的密码)]))
            解密结果 += 解密后字符
        return 解密结果
    except Exception:  # 捕获所有异常
        return ""


def 文本_取出文本中汉字(字符串):
    """
    从文本中提取汉字。

    参数:
        字符串 (str): 要从中提取汉字的文本。

    返回:
        str: 提取出的汉字文本。如果出现任何异常，则返回 False。

    示例:
        文本 = "这是一段中文文本，English words are also included."
        汉字文本 = 文本_取出文本中汉字(文本)
        print("取出的汉字文本:", 汉字文本)
    """
    try:
        汉字列表 = [char for char in 字符串 if '\u4e00' <= char <= '\u9fff']
        return ''.join(汉字列表)
    except Exception:  # 捕获所有异常
        return False


def 文本_取出现次数(被搜索文本, 欲搜索文本, 是否区分大小写=False):
    """
    计算文本中某子串出现的次数。

    参数:
        被搜索文本 (str): 要搜索的原始文本。
        欲搜索文本 (str): 要搜索的子串文本。
        是否区分大小写 (bool): 是否区分大小写，默认为 False。

    返回:
        int: 搜索文本在被搜索文本中出现的次数。如果出现任何异常，则返回 False。

    示例:
        文本 = "This is a sample text. This text is for demonstration purposes."
        搜索文本 = "Text"
        出现次数 = 文本_取出现次数(文本, 搜索文本)
        print("搜索文本出现的次数:", 出现次数)
    """
    try:
        if not 是否区分大小写:
            被搜索文本 = 被搜索文本.lower()
            欲搜索文本 = 欲搜索文本.lower()

        return 被搜索文本.count(欲搜索文本)
    except Exception:  # 捕获所有异常
        return False


def 文本_取出中间文本(欲取全文本, 前面文本, 后面文本, 起始搜寻位置=None, 是否不区分大小写=False):
    """
    从全文本中提取位于前文本和后文本之间的中间文本。

    参数:
        欲取全文本 (str): 要搜索的全文本。
        前面文本 (str): 中间文本的前部分。
        后面文本 (str): 中间文本的后部分。
        起始搜寻位置 (int): 可选参数，指定搜索起始位置，默认为 None。
        是否不区分大小写 (bool): 是否不区分大小写，默认为 False。

    返回:
        str: 提取出的中间文本。如果出现任何异常或找不到指定的前后文本，则返回空字符串。

    示例:
        全文本 = "这是一个示例文本，中间包含了要取出的部分。"
        前文本 = "示例文本，中间包含了"
        后文本 = "部分。"
        中间文本 = 文本_取出中间文本(全文本, 前文本, 后文本)
        print("取出的中间文本:", 中间文本)
    """
    try:
        if 是否不区分大小写:
            欲取全文本 = 欲取全文本.lower()
            前面文本 = 前面文本.lower()
            后面文本 = 后面文本.lower()

        if 起始搜寻位置 is not None:
            起始索引 = 欲取全文本.find(前面文本, 起始搜寻位置)
        else:
            起始索引 = 欲取全文本.find(前面文本)

        if 起始索引 == -1:
            return ""

        起始索引 += len(前面文本)
        结束索引 = 欲取全文本.find(后面文本, 起始索引)
        if 结束索引 == -1:
            return ""

        return 欲取全文本[起始索引:结束索引]
    except Exception:  # 捕获所有异常
        return ""


def 文本_取随机字符(要取的字符数, 获取模式=1):
    """
    返回随机生成的指定数量和模式的字符。

    参数:
    要取的字符数 (int): 指定要生成的字符数量。
    获取模式 (int): 指定要生成的字符模式。1=数字, 2=小写字母, 4=大写字母, 8=特殊字符。
                    可以组合多个模式，例如：获取模式=2 | 4 会同时包含小写字母和大写字母。

    示例:
    随机数字 = 文本_取随机字符(10, 1)
    print("随机数字:", 随机数字)

    随机字母 = 文本_取随机字符(10, 2 | 4)
    print("随机字母:", 随机字母)

    随机字符 = 文本_取随机字符(10, 1 | 2 | 4 | 8)
    print("随机字符:", 随机字符)
    """
    可见字符集合 = ""
    if 获取模式 & 1:
        可见字符集合 += string.digits
    if 获取模式 & 2:
        可见字符集合 += string.ascii_lowercase
    if 获取模式 & 4:
        可见字符集合 += string.ascii_uppercase
    if 获取模式 & 8:
        可见字符集合 += string.punctuation

    随机字符列表 = random.choices(可见字符集合, k=要取的字符数)
    return ''.join(随机字符列表)


def 文本_取文本所在行(源文本, 欲查找的文本, 是否区分大小写=False):
    """
    从源文本中查找文本，并返回其所在行号。

    参数:
        源文本 (str): 要搜索的源文本。
        欲查找的文本 (str): 要查找的文本。
        是否区分大小写 (bool): 是否区分大小写，默认为 False。

    返回:
        int: 查找文本所在行的行号，如果未找到文本或出现任何异常，则返回 -1。

    示例:
        文本 = "This is the fourth line"
        欲查找的文本 = "fourth"
        行号 = 文本_取文本所在行(文本, 欲查找的文本)
        print("欲查找文本所在行号:", 行号)
    """
    try:
        if not 是否区分大小写:
            源文本 = 源文本.lower()
            欲查找的文本 = 欲查找的文本.lower()

        行列表 = 源文本.splitlines()
        for 行号, 行文本 in enumerate(行列表, start=1):
            if 欲查找的文本 in 行文本:
                return 行号

        return -1
    except Exception:  # 捕获所有异常
        return -1


def 文本_取行数(文本):
    """
    统计文本的行数。

    参数:
        文本 (str): 要统计行数的文本。

    返回:
        int: 文本的行数，如果出现任何异常，则返回 -1。

    示例:
        文本 = "这是第一行"
        行数 = 文本_取行数(文本)
        print("文本共有", 行数, "行")
    """
    try:
        行数 = len(文本.splitlines())
        return 行数
    except Exception:  # 捕获所有异常
        return -1


def 文本_取右边(被查找的文本, 欲寻找的文本, 起始寻找位置=0, 是否不区分大小写=False):
    """
    # 示例用法
    被查找的文本 = "这是一个示例文本，Python是一种很强大的编程语言"
    欲寻找的文本 = "Python"
    结果 = 文本_取右边(被查找的文本, 欲寻找的文本, 1, True)
    print(结果)  # 输出：是一种很强大的编程语言
    """
    if 是否不区分大小写:
        被查找的文本 = 被查找的文本.lower()
        欲寻找的文本 = 欲寻找的文本.lower()

    寻找位置 = 被查找的文本.find(欲寻找的文本, 起始寻找位置)
    if 寻找位置 != -1:
        return 被查找的文本[寻找位置 + len(欲寻找的文本):]
    else:
        return ""


def 文本_取长度(源文本):
    """
    获取文本的长度。

    参数:
        源文本 (str): 要获取长度的文本。

    返回:
        int: 文本的长度，如果出现任何异常，则返回 -1。

    示例:
        文本 = "这是一段示例文本a"
        长度 = 文本_取长度(文本)
        print("文本的长度:", 长度)
    """
    try:
        return len(源文本)
    except Exception:  # 捕获所有异常
        return -1


def 文本_取指定变量文本行(文本, 行号):
    """
    # 示例用法
    源文本 = "这是第一行"
    行号 = 1
    文本行 = 文本_取指定变量文本行(源文本, 行号)
    print("第", 行号, "行的文本:", 文本行)
    """
    行列表 = 文本.splitlines()
    行数 = len(行列表)
    if 1 <= 行号 <= 行数:
        return 行列表[行号 - 1]
    else:
        return ""


def 文本_取左边(被查找的文本, 欲寻找的文本, 起始寻找位置=1, 是否不区分大小写=False):
    """
    # 示例用法
    文本 = "这是一个示例文本，包含要寻找的文本"
    欲寻找的文本 = "示例"
    左边文本 = 文本_取左边(文本, 欲寻找的文本)
    print("欲寻找文本左边的内容:", 左边文本)
    """
    if 是否不区分大小写:
        被查找的文本 = 被查找的文本.lower()
        欲寻找的文本 = 欲寻找的文本.lower()

    if 起始寻找位置 < 0:
        被查找的文本 = 被查找的文本[::-1]
        欲寻找的文本 = 欲寻找的文本[::-1]

    index = 被查找的文本.find(欲寻找的文本, abs(起始寻找位置) - 1)
    if index != -1:
        return 被查找的文本[:index]
    else:
        return ""


def 文本_替换行内容(文本, 行数, 替换内容):
    """
    # 示例用法
    源文本 = "这是第一行\n这是第二行\n这是第三行"
    行号 = 2
    替换文本 = "曾凤翔"
    替换后文本 = 文本_替换行内容(源文本, 行号, 替换文本)
    print("替换后的文本:")
    print(替换后文本)
    """
    行列表 = 文本.splitlines()
    行数 -= 1  # 行数从1开始计数，列表索引从0开始，需要减1
    if 0 <= 行数 < len(行列表):
        行列表[行数] = 替换内容
        return '\n'.join(行列表)
    else:
        return 文本


def 文本_十六进制替换(十六进制文本, 要替换的旧十六进制, 替换为的新十六进制):
    """
    将十六进制文本中的指定内容替换为新内容。

    参数:
        十六进制文本 (str): 十六进制文本。
        要替换的旧十六进制 (str): 要替换的十六进制内容。
        替换为的新十六进制 (str): 替换后的新十六进制内容。

    返回:
        str: 替换后的十六进制文本，如果出现任何异常，则返回 None。

    示例:
        十六进制文本 = "48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21"
        新的十六进制文本 = 十六进制替换(十六进制文本, "6c 6c", "aa")
        print("替换后的十六进制文本:", 新的十六进制文本)  # 输出: 48 65 aa 6f 2c 20 57 6f 72 6c 64 21
    """
    try:
        # 将十六进制字符串转换为字节列表
        字节列表 = bytes.fromhex(十六进制文本.replace(' ', ''))
        # 将要替换的十六进制内容转换为字节
        旧字节 = bytes.fromhex(要替换的旧十六进制)
        # 将新的十六进制内容转换为字节
        新字节 = bytes.fromhex(替换为的新十六进制)
        # 替换所有匹配的内容
        替换后的字节列表 = 字节列表.replace(旧字节, 新字节)
        # 将替换后的字节列表转换为十六进制字符串
        替换后的十六进制文本 = ' '.join([format(字节, '02x') for 字节 in 替换后的字节列表])
        return 替换后的十六进制文本
    except Exception:
        return None


def 文本_字符串替换(源字符串, 要替换的旧子串, 替换为的新子串):
    """
    将字符串中的指定子串替换为新子串。

    参数:
        源字符串 (str): 要进行替换操作的源字符串。
        要替换的旧子串 (str): 要被替换的子串。
        替换为的新子串 (str): 替换后的新子串。

    返回:
        str: 替换完成后的字符串，如果出现任何异常，则返回 None。

    示例:
        源字符串 = "Hello, World!"
        替换后的字符串 = 字符串替换(源字符串, "World", "Universe")
        print("替换后的字符串:", 替换后的字符串)  # 输出: Hello, Universe!
    """
    try:
        替换后的字符串 = 源字符串.replace(要替换的旧子串, 替换为的新子串)
        return 替换后的字符串
    except Exception:
        return None


def 文本区分_只取符号(源文本):
    """
    从源文本中提取符号。

    参数:
        源文本 (str): 要提取符号的源文本。

    返回:
        str: 提取的符号字符串，如果出现任何异常，则返回空字符串。

    示例:
        源文本 = "这是一个示例文本，包含一些符号：!?@#$%^&*()_+"
        符号文本 = 文本区分_只取符号(源文本)
        print("提取的符号文本:", 符号文本)
    """
    try:
        # 使用正则表达式匹配非字母、非数字、非空格的字符
        符号列表 = re.findall(r'[^\w\s]', 源文本)
        # 将符号列表连接成一个字符串并返回
        return ''.join(符号列表)
    except Exception:
        return ""


def 文本区分_只取汉字(源文本):
    """
    # 示例用法
    源文本 = "这是一个示例文本，包含一些汉字：你好，世界！"
    汉字文本 = 文本区分_只取汉字(源文本)
    print("提取的汉字文本:", 汉字文本)
    """
    汉字列表 = [字符 for 字符 in 源文本 if '\u4e00' <= 字符 <= '\u9fa5']
    # 将汉字列表连接成一个字符串并返回
    return ''.join(汉字列表)


def 文本区分_只取数字(源文本):
    """
    # 示例用法
    源文本 = "这是一个示例文本，包含一些数字：1234567890"
    数字文本 = 文本区分_只取数字(源文本)
    print("提取的数字文本:", 数字文本)
    """
    # 使用正则表达式匹配数字
    数字列表 = ''.join(filter(str.isdigit, 源文本))
    return 数字列表


def 文本_取文本最后出现的位置(文本, 查找的文本):
    """
    返回指定文本中指定子串最后一次出现的位置。

    参数：
    文本 (str): 要搜索的文本。
    查找的文本 (str): 要查找的文本。

    返回值：
    int: 最后一次出现的位置索引，如果没有找到或者出现异常则返回-1。
    """
    try:
        # 使用rfind函数查找子串最后一次出现的位置
        最后位置 = 文本.rfind(查找的文本)
        return 最后位置
    except Exception:
        return -1


def 文本_取文本首次出现的位置(文本, 查找的文本):
    """
    返回指定文本中指定子串首次出现的位置。

    参数：
    文本 (str): 要搜索的文本。
    查找的文本 (str): 要查找的子串。

    返回值：
    int: 子串首次出现的位置索引，如果没有找到返回-1。
    """
    try:
        # 使用find函数查找子串首次出现的位置
        首次位置 = 文本.find(查找的文本)
        return 首次位置
    except Exception:
        return -1


def 文本_取文本指定次数出现的位置(文本, 子串, 次数):
    """
    返回指定文本中指定子串出现的指定次数后的位置。

    参数：
    文本 (str): 要搜索的文本。
    子串 (str): 要查找的子串。
    次数 (int): 子串第几次出现的位置

    返回值：
    int: 子串指定次数出现后的位置索引，如果没有找到或者次数超过实际出现次数返回-1。

    使用示例：
    文本_取文本指定次数出现的位置("ABABABABABA", "A", 3)
    以上参数传递的意思就是，寻找ABABABABABA 这个字符串内第三个A 出现的位置，
    """
    try:
        # 初始化计数器和位置索引
        计数器 = 0
        位置索引 = -1

        # 使用循环查找指定次数后的位置
        while 计数器 < 次数:
            位置索引 = 文本.find(子串, 位置索引 + 1)
            if 位置索引 == -1:
                break
            计数器 += 1

        return 位置索引
    except Exception:
        return -1