生成计算型验证码图片

用opencv-python处理图片

制作训练数据集

训练模型

识别验证码

总结与提高

源码下载

在本节我们将使用sklearn和opencv-python这两个库过掉计算型验证码，图片示例如下。

生成计算型验证码图片

要识别验证码，我们就需要大量验证码图片用于机器学习，以下是生成计算型验证码图片的完整代码。

from PIL import Image, ImageDraw, ImageFont
import concurrent.futures
from pathlib import Path
import random
import shutil


IMG_WIDTH = 160     # 图片宽度
IMG_HEIGHT = 60     # 图片高度
FONT_SIZE = 30      # 字体大小


def get_random_point():
    """获取随机点坐标"""
    x = random.randint(0, IMG_WIDTH)
    y = random.randint(0, IMG_HEIGHT)
    return x, y


def get_random_color(min_val=0, max_val=255):
    """获取随机颜色"""
    r = random.randint(min_val, max_val)
    g = random.randint(min_val, max_val)
    b = random.randint(min_val, max_val)
    return r, g, b


def draw_bg_noise(img, pen):
    """制造背景噪点"""
    noise_num = IMG_WIDTH * IMG_HEIGHT // 8  # 要绘制的噪点数量
    for i in range(noise_num):
        x, y = get_random_point()
        color = get_random_color(min_val=150, max_val=255)
        pen.point((x, y), color)
    return img


def operator2Chinese(text):
    """将运算符转成中文"""
    return text.replace("+", "加").replace("-", "减").replace("*", "乘").replace("/", "除以")


def Chinese2operator(text):
    """将中文转为运算符"""
    return text.replace("加", "+").replace("减", "-").replace("乘", "*").replace("除以", "/")


def draw_texts(img, pen):
    """绘制文本"""
    number_seed = "0123456789"      # 数字字符池
    operator_seed = "+-*/"          # 运算符号字符池

    # 将数字转为int的目的是去除开头的0
    # number2加上1是为了防止除数为0的情况
    number1 = str(int("".join(random.sample(number_seed, random.randint(1, 3)))))
    number2 = str(int("".join(random.sample(number_seed, random.randint(1, 3)))) + 1)
    operator_char = random.choice(operator_seed)

    font = ImageFont.truetype("Arial", size=random.randint(FONT_SIZE - 5, FONT_SIZE + 5))
    pen.text((5, 15), number1, get_random_color(max_val=150), font)

    font = ImageFont.truetype("Arial", size=random.randint(FONT_SIZE - 5, FONT_SIZE + 5))
    pen.text((65, 15), operator_char, get_random_color(max_val=150), font)

    font = ImageFont.truetype("Arial", size=random.randint(FONT_SIZE - 5, FONT_SIZE + 5))
    pen.text((90, 15), number2, get_random_color(max_val=150), font)

    chars = operator2Chinese(number1+operator_char+number2)
    return img, chars


def generate_captcha(num, output_dir, thread_name=0):
    """
    生成一定数量的验证码图片
    :param num: 生成数量
    :param output_dir: 存放验证码图片的文件夹路径
    :param thread_name: 线程名称
    :return: None
    """
    # 目录存在则删除
    if Path(output_dir).exists():
        shutil.rmtree(output_dir)

    # 创建目录
    Path(output_dir).mkdir()

    for i in range(num):
        img = Image.new("RGB", size=(IMG_WIDTH, IMG_HEIGHT), color="white")
        pen = ImageDraw.Draw(img, mode="RGB")

        img, text = draw_texts(img, pen)
        img = draw_bg_noise(img, pen)

        save_path = f"{output_dir}/{i + 1}-{text}.png"
        img.save(save_path, format="png")
        print(f"Thread {thread_name}: 已生成{i + 1}张验证码")

    print(f"Thread {thread_name}: 验证码图片生成完毕")


def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        for i in range(3):
            executor.submit(generate_captcha, 10000, f"./captcha{i}", i)


if __name__ == "__main__":
    main()

该程序使用Pillow库生成随机的计算型验证码图片，像素为160px*60px，图片上还设置了噪点。图片上的字符数量取决于数字的位数，数字位数最小为1，最大为3，所以图片上字符数量最小为3，最大为7。在main()函数中，我们开启了3个子线程，每一个子线程负责生成10000张验证码并保存在各自的文件夹中。

注：为了提高图像处理的质量，笔者用这行代码get_random_color(max_val=150)将字符随机颜色的最大值设置成了150，这样字符颜色就会比较深，在切割图像时失败概率会减少，方便演示。当然实际验证码肯定会出现颜色比较浅的字符。

注：在保存图片时，笔者将图片名称中的+-*/替换成了中文，因为文件命名中不能包含特殊符号。

用opencv-python处理图片

将验证码图片交给模型识别前的一个重要操作就是图像处理。为了提高识别精读，我们应该将噪点去除，还好我们用opencv-python很容易就能够去除噪点。下方的adjust_img()函数会返回一个二值化后的验证码图片。

# process.py
def adjust_img(img):
    """调整图像"""
    # 图片灰度化
    img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # 高斯模糊
    img_gaussian = cv.GaussianBlur(img_gray, (3, 3), 0)

    # 二值化
    ret, img_threshold = cv.threshold(img_gaussian, 0, 255,
                                      cv.THRESH_BINARY_INV + cv.THRESH_OTSU)

    return img_threshold

高斯模糊可以有效去除图像中的噪点，处理后的效果显示如下。

我们要用sklearn识别单个字符（这样识别难度会小一些），而验证码上是3-7个字符，所以我们应该将验证码图片进行切割，切割后的每张图片只包含一个字符。下方的split_img()函数实现了这个功能。

# process.py
def split_img(img, real_captcha):
    """分割图像"""
    cnts, hiers = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    if len(cnts) != len(real_captcha):
        return False, None

    roi_list = []
    bg_width, bg_height = 40, 40
    for cnt in sorted(cnts, key=lambda x: cv.boundingRect(x)[0]):
        x, y, w, h = cv.boundingRect(cnt)

        # 如果cnt大小大于bg背景大小，则抛弃该验证码
        if w > bg_width or h > bg_height:
            return False, None

        roi = img[y:y+h, x:x+w]
        bg = np.zeros((bg_width, bg_height))

        start_x = (bg_width - w) // 2
        start_y = (bg_height - h) // 2
        bg[start_y:start_y+h, start_x:start_x+w] = roi

        bg = cv.resize(bg, (20, 20))
        bg[bg < 125] = 0
        bg[bg >= 125] = 1
        roi_list.append(bg)

    return True, roi_list

验证码字符位置会有变化，而且字符数量不能确定，所以不应该通过图片均分切割去获取单个字符，而是应该用opencv-python的findContours()方法去寻找各个的字符轮廓并截取。截取出来的字符图像被放进了40*40像素的黑色背景中，确保所有字符图像的大小一致。最后将图像调整为20*20，这样训练数据的特征数也会少一些。

如果有一些字符的颜色比较浅，那在图像二值化处理时，这些字符的像素值就会被设为0，那findContours()方法返回的轮廓数跟验证码上的实际字符数就会不一样，此时就要舍弃该验证码，不能将其放进训练数据中。如果轮廓宽高大于黑色背景宽高40，那就会导致无法将轮廓放进黑色背景中，最终的字符数量也会跟实际的不一样，这种验证码也就只能先舍弃掉。

笔者通过以下代码将图像中值变成了0和1，这样更有利于机器学习。

bg[bg < 125] = 0
bg[bg >= 125] = 1

切割结果如下所示：

我们要知道的一点是，在图像处理这一步骤中，有少部分验证码图片肯定会不合格，不能拿来放进机器学习数据集中，也无法被正常识别。图像处理的好坏跟识别准确度高低有很大关系。图像处理的完整代码如下所示。

# process.py
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
from captcha import Chinese2operator


def adjust_img(img):
    """调整图像"""
    # 图片灰度化
    img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # 高斯模糊
    img_gaussian = cv.GaussianBlur(img_gray, (3, 3), 0)

    # 二值化
    ret, img_threshold = cv.threshold(img_gaussian, 0, 255,
                                      cv.THRESH_BINARY_INV + cv.THRESH_OTSU)

    return img_threshold


def split_img(img, real_captcha):
    """分割图像"""
    cnts, hiers = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    if len(cnts) != len(real_captcha):
        return False, None

    roi_list = []
    bg_width, bg_height = 40, 40
    for cnt in sorted(cnts, key=lambda x: cv.boundingRect(x)[0]):
        x, y, w, h = cv.boundingRect(cnt)

        # 如果cnt大小大于bg背景大小，则抛弃该验证码
        if w > bg_width or h > bg_height:
            return False, None

        roi = img[y:y+h, x:x+w]
        bg = np.zeros((bg_width, bg_height))

        start_x = (bg_width - w) // 2
        start_y = (bg_height - h) // 2
        bg[start_y:start_y+h, start_x:start_x+w] = roi

        bg = cv.resize(bg, (20, 20))
        bg[bg < 125] = 0
        bg[bg >= 125] = 1
        roi_list.append(bg)

    return True, roi_list


def main():
    file_path = "captcha0/3-723除以14.png"
    img = cv.imread(file_path)
    img = adjust_img(img)

    real_captcha = Chinese2operator(file_path.split("-")[-1].replace(".png", ""))
    is_ok, roi_list = split_img(img, real_captcha)
    if not is_ok:
        return

    for i, roi in enumerate(roi_list):
        plt.subplot(1, len(roi_list), i+1)
        plt.axis("off")
        plt.imshow(roi, cmap="gray")
    plt.show()


if __name__ == "__main__":
    main()

制作训练数据集

验证码图片有了，图像处理也好了，接下来就是把所有单个数字图像保存为训练数据集，完整代码如下所示。

# data.py
import os
import cv2 as cv
import numpy as np
from pathlib import Path
import concurrent.futures
from captcha import Chinese2operator
from process import adjust_img, split_img


def make_data(captcha_dir, thread_name=0):
    """制作训练数据集"""
    data = []                                       # 特征数据
    target = []                                     # 数据标签
    seed = "0123456789+-*/"                         # 字符池

    for i, filename in enumerate(os.listdir(captcha_dir)):
        print(f"Thread {thread_name}: 正在处理第{i+1}张图片")
        file_path = f"{captcha_dir}/{filename}"
        real_captcha = Chinese2operator(file_path.split("-")[-1].replace(".png", ""))

        img = cv.imread(file_path)
        img = adjust_img(img)

        is_ok, roi_list = split_img(img, real_captcha)
        if not is_ok:
            continue

        for i, roi in enumerate(roi_list):
            data.append(roi.ravel())
            target.append(seed.index(real_captcha[i]))

    data = np.array(data)
    target = np.array(target)

    Path("./data").mkdir(exist_ok=True)
    Path("./target").mkdir(exist_ok=True)
    np.save(f"./data/data{thread_name}.npy", data)
    np.save(f"./target/target{thread_name}.npy", target)

    print(f"Thread {thread_name}: 已保存数据和标签")


def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        for i in range(3):
            executor.submit(make_data, f"./captcha{i}", i)


if __name__ == "__main__":
    main()

该程序开启了3个子线程，每个线程负责一个验证码文件夹中的所有图片。最终结果是将所有单个图片数据以及对应的标签保存在npy格式的文件中。

注：要记得将标签从字符串类型转换成数值类型，笔者这里用字符在seed变量中的索引来表示对应的标签字符。

训练模型

有了数据之后就可以开始训练了。首先，我们应该把各个npy数据加载进来，并正进行整合，请看以下代码。

# train.py
def load_data():
    """加载各个npy数据，返回整合后的数据"""
    data_list = []
    target_list = []
    for i in range(3):
        data_list.append(np.load(f"./data/data{i}.npy"))

    for i in range(3):
        target_list.append(np.load(f"./target/target{i}.npy"))

    X = np.vstack(data_list)
    y = np.hstack(target_list)

    print(X.shape)
    print(y.shape)

    return X, y

训练数据量显示如下：

通过以下代码可以得知各个字符的数量。

from collections import Counter
Counter(sorted(y))

Counter({0: 7452,
         1: 12334,
         2: 11327,
         3: 11288,
         4: 10706,
         5: 11139,
         6: 11355,
         7: 11637,
         8: 11153,
         9: 11487,
         10: 7150,
         11: 6969,
         12: 7154,
         13: 7000})

接下来，选择最合适的模型，不断调参（这里其实会花费很多时间）。出于演示目的，笔者这里就选择KNN了，请看以下代码。

# train.py
def get_best_estimator(X, y):
    """调整参数，获取最佳的KNN模型"""
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    param_grid = {
        "n_neighbors": [i for i in range(5, 13, 2)]
    }
    grid_search = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
    grid_search.fit(X_train, y_train)
    print(grid_search.score(X_test, y_test))

    pred = grid_search.predict(X_test)
    print(classification_report(y_test, pred))

    return grid_search.best_estimator_

在get_best_estimator()函数中，我们用GridSearchCV进行参数选择与模型评估，评分和报告如下所示。

0.9987333067930947

              precision    recall  f1-score   support

           0    0.99577   0.99929   0.99753      1412
           1    1.00000   1.00000   1.00000      2478
           2    0.99956   1.00000   0.99978      2280
           3    1.00000   0.99956   0.99978      2290
           4    0.99954   0.99907   0.99931      2161
           5    1.00000   0.99866   0.99933      2244
           6    0.99863   0.99909   0.99886      2196
           7    0.99957   1.00000   0.99978      2317
           8    0.99956   0.99911   0.99933      2250
           9    1.00000   0.99865   0.99932      2218
          10    0.99930   0.99860   0.99895      1431
          11    0.98880   0.99929   0.99402      1414
          12    0.99649   0.98886   0.99266      1436
          13    1.00000   0.99867   0.99933      1504

    accuracy                        0.99873     27631
   macro avg    0.99837   0.99849   0.99843     27631
weighted avg    0.99874   0.99873   0.99873     27631

模型训练好了之后，我们就可以将它进行保存，请看以下代码。

# train.py
def save_model(best_estimator):
    """保存模型"""
    with open("./model.pkl", "wb") as f:
        pickle.dump(best_estimator, f)

训练部分的完整代码所示如下：

# train.py
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report
import numpy as np
import pickle


def load_data():
    """加载各个npy数据，返回整合后的数据"""
    data_list = []
    target_list = []
    for i in range(3):
        data_list.append(np.load(f"./data/data{i}.npy"))

    for i in range(3):
        target_list.append(np.load(f"./target/target{i}.npy"))

    X = np.vstack(data_list)
    y = np.hstack(target_list)

    print(X.shape)
    print(y.shape)

    return X, y


def get_best_estimator(X, y):
    """调整参数，获取最佳的KNN模型"""
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    param_grid = {
        "n_neighbors": [i for i in range(5, 13, 2)]
    }
    grid_search = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
    grid_search.fit(X_train, y_train)
    print(grid_search.score(X_test, y_test))

    pred = grid_search.predict(X_test)
    print(classification_report(y_test, pred))

    return grid_search.best_estimator_


def save_model(best_estimator):
    """保存模型"""
    with open("./model.pkl", "wb") as f:
        pickle.dump(best_estimator, f)


def main():
    X, y = load_data()
    best_estimator = get_best_estimator(X, y)
    save_model(best_estimator)


if __name__ == "__main__":
    main()

识别验证码

我们再生成1000张验证码图片用于测试模型的识别能力。首先加载训练好的模型。

def load_model(mode_path):
    """加载模型"""
    with open(mode_path, "rb") as f:
        model = pickle.load(f)
    return model

然后是编写预测代码。

# predict.py
def predict(model, file_path):
    seed = "0123456789+-*/"   # 字符池

    img = cv.imread(file_path)
    img = adjust_img(img)

    # 预测结果和真实结果
    predict_result = ""
    real_captcha = Chinese2operator(file_path.split("-")[-1].replace(".png", ""))

    # 如果图像处理成功，则返回单个数字图像的预测结果和真实结果
    # 如果没成功，则返回0000和真实结果
    is_ok, roi_list = split_img(img, real_captcha)
    if is_ok:
        for i, roi in enumerate(roi_list):
            predict_result += seed[(model.predict(roi.reshape(1, -1))[0])]
        print(f"{file_path}的识别结果为{predict_result}，运算结果为{eval(predict_result)}")
        return predict_result, real_captcha
    else:
        print(f"{file_path}图片处理失败")
        return False, None

在predict()函数中，我们首先读取了图片并对图像进行处理和分割，然后调用model.predict()方法进行预测。model.predict()方法返回的是一个索引值，需要对应seed变量获取对应字符。获取到识别结果后，我们直接使用eval()函数计算出结果。如果图像处理失败，则返回False和None，不参与最后的识别精度值计算。

预测结果要和真实结果比对后就可以得到准确度了，请看以下代码。

# predict.py
def get_accuracy(model, captcha_dir):
    """获取验证准确度"""
    all_predict_result = []
    all_real_result = []

    for filename in sorted(os.listdir(captcha_dir)):
        if filename != ".DS_Store":  # Mac电脑上的一种文件，排除掉
            predict_result, real_result = predict(model, f"{captcha_dir}/{filename}")
            if predict_result:
                all_predict_result.append(predict_result)
                all_real_result.append(real_result)

    accuracy = (np.array(all_predict_result) == np.array(all_real_result)).sum() / len(all_predict_result)
    return accuracy

经笔者测试，accuracy的值在0.99左右，模型识别能力很强。

./captcha_verify/1-93乘346.png的识别结果为93*346，运算结果为32178
./captcha_verify/10-406减10.png的识别结果为406-10，运算结果为396
./captcha_verify/100-92乘39.png的识别结果为92*39，运算结果为3588
./captcha_verify/1000-28减72.png的识别结果为28-72，运算结果为-44
./captcha_verify/101-14乘6.png的识别结果为14*6，运算结果为84
./captcha_verify/102-92加626.png的识别结果为92+626，运算结果为718
./captcha_verify/103-15乘3.png的识别结果为15*3，运算结果为45
./captcha_verify/104-89减3.png的识别结果为89-3，运算结果为86
./captcha_verify/105-5加5.png的识别结果为5+5，运算结果为10
./captcha_verify/106-834除以6.png的识别结果为834/6，运算结果为139.0
./captcha_verify/107-5除以58.png的识别结果为5/58，运算结果为0.08620689655172414
./captcha_verify/108-89加565.png的识别结果为89+565，运算结果为654
./captcha_verify/109-948除以1.png的识别结果为948/1，运算结果为948.0
./captcha_verify/11-856乘571.png的识别结果为856*571，运算结果为488776
./captcha_verify/110-90除以2.png的识别结果为90/2，运算结果为45.0
./captcha_verify/111-94减41.png的识别结果为94-41，运算结果为53
./captcha_verify/112-91加4.png的识别结果为91+4，运算结果为95
./captcha_verify/113-721乘466.png的识别结果为721*466，运算结果为335986
./captcha_verify/114-0加24.png的识别结果为0+24，运算结果为24
./captcha_verify/115-46除以174.png的识别结果为46/174，运算结果为0.26436781609195403
./captcha_verify/116-9减53.png的识别结果为9-53，运算结果为-44
./captcha_verify/117-5除以10.png的识别结果为5/10，运算结果为0.5
./captcha_verify/118-0除以29.png的识别结果为0/29，运算结果为0.0
./captcha_verify/119-427加10.png的识别结果为427+10，运算结果为437
./captcha_verify/12-0乘15.png的识别结果为0*15，运算结果为0
./captcha_verify/120-971除以420.png的识别结果为971/420，运算结果为2.3119047619047617
./captcha_verify/121-4乘170.png的识别结果为4*170，运算结果为680
./captcha_verify/122-628乘821.png的识别结果为628*821，运算结果为515588
./captcha_verify/123-60乘402.png的识别结果为60*402，运算结果为24120
./captcha_verify/124-4减75.png的识别结果为4-75，运算结果为-71
./captcha_verify/125-7加470.png的识别结果为7+470，运算结果为477
./captcha_verify/126-35乘7.png的识别结果为35*7，运算结果为245
./captcha_verify/127-2除以8.png的识别结果为2/8，运算结果为0.25
./captcha_verify/128-481加71.png的识别结果为481+71，运算结果为552
./captcha_verify/129-6减672.png的识别结果为6-672，运算结果为-666
./captcha_verify/13-6减9.png的识别结果为6-9，运算结果为-3
./captcha_verify/130-176加215.png的识别结果为176+215，运算结果为391
./captcha_verify/131-3加44.png的识别结果为3+44，运算结果为47
./captcha_verify/132-7减808.png图片处理失败
./captcha_verify/133-803加16.png的识别结果为803+16，运算结果为819
./captcha_verify/134-890减5.png的识别结果为890-5，运算结果为885
./captcha_verify/135-7减5.png的识别结果为7-5，运算结果为2
./captcha_verify/136-3乘6.png的识别结果为3*6，运算结果为18
./captcha_verify/137-547乘50.png的识别结果为547*50，运算结果为27350
./captcha_verify/138-986加52.png的识别结果为986+52，运算结果为1038
./captcha_verify/139-35减121.png的识别结果为35-121，运算结果为-86
./captcha_verify/14-7乘821.png的识别结果为7*821，运算结果为5747
./captcha_verify/140-14除以5.png的识别结果为14/5，运算结果为2.8
./captcha_verify/141-18乘13.png的识别结果为18*13，运算结果为234
./captcha_verify/142-25加9.png的识别结果为25+9，运算结果为34
./captcha_verify/143-841减87.png的识别结果为841-87，运算结果为754
./captcha_verify/144-649加894.png图片处理失败
./captcha_verify/145-103乘6.png图片处理失败
./captcha_verify/146-7除以6.png的识别结果为7/6，运算结果为1.1666666666666667
./captcha_verify/147-5除以31.png的识别结果为5/31，运算结果为0.16129032258064516
./captcha_verify/148-65加68.png的识别结果为65+68，运算结果为133
./captcha_verify/149-95加59.png的识别结果为95+59，运算结果为154
./captcha_verify/15-9减185.png的识别结果为9-185，运算结果为-176
./captcha_verify/150-28减1.png的识别结果为28-1，运算结果为27
./captcha_verify/151-635减81.png的识别结果为635-81，运算结果为554
./captcha_verify/152-490除以833.png的识别结果为490/833，运算结果为0.5882352941176471
./captcha_verify/153-54加2.png图片处理失败
./captcha_verify/154-1加2.png的识别结果为1+2，运算结果为3
./captcha_verify/155-546减69.png的识别结果为546-69，运算结果为477
./captcha_verify/156-2乘55.png的识别结果为2*55，运算结果为110
./captcha_verify/157-2乘3.png的识别结果为2*3，运算结果为6
./captcha_verify/158-41减681.png的识别结果为41-681，运算结果为-640
./captcha_verify/159-308除以5.png的识别结果为308/5，运算结果为61.6
./captcha_verify/16-7除以1.png的识别结果为7/1，运算结果为7.0
./captcha_verify/160-8加735.png的识别结果为8+735，运算结果为743
./captcha_verify/161-893乘32.png的识别结果为893*32，运算结果为28576
./captcha_verify/162-7除以57.png的识别结果为7/57，运算结果为0.12280701754385964
./captcha_verify/163-4减19.png的识别结果为4-19，运算结果为-15
./captcha_verify/164-0除以51.png的识别结果为0/51，运算结果为0.0
./captcha_verify/165-64除以5.png的识别结果为64/5，运算结果为12.8
./captcha_verify/166-3乘4.png的识别结果为3*4，运算结果为12
./captcha_verify/167-892除以7.png的识别结果为892/7，运算结果为127.42857142857143
./captcha_verify/168-325除以50.png的识别结果为325/50，运算结果为6.5
./captcha_verify/169-813减66.png的识别结果为813-66，运算结果为747
./captcha_verify/17-24减4.png的识别结果为24-4，运算结果为20
./captcha_verify/170-813除以9.png的识别结果为813/9，运算结果为90.33333333333333
./captcha_verify/171-6乘531.png的识别结果为6*531，运算结果为3186
./captcha_verify/172-697减822.png的识别结果为697-822，运算结果为-125
./captcha_verify/173-6乘58.png的识别结果为6*58，运算结果为348
./captcha_verify/174-0加87.png图片处理失败
./captcha_verify/175-4加49.png的识别结果为4+49，运算结果为53
./captcha_verify/176-5乘597.png的识别结果为5*597，运算结果为2985
./captcha_verify/177-97乘32.png的识别结果为97*32，运算结果为3104
./captcha_verify/178-4乘926.png的识别结果为4*926，运算结果为3704
./captcha_verify/179-865乘1.png的识别结果为865*1，运算结果为865
./captcha_verify/18-0加5.png的识别结果为0+5，运算结果为5
./captcha_verify/180-9乘60.png的识别结果为9*60，运算结果为540
./captcha_verify/181-83加376.png的识别结果为83+376，运算结果为459
./captcha_verify/182-158除以7.png的识别结果为158/7，运算结果为22.571428571428573
./captcha_verify/183-6除以742.png的识别结果为6/742，运算结果为0.008086253369272238
./captcha_verify/184-7乘4.png的识别结果为7*4，运算结果为28
./captcha_verify/185-671减8.png的识别结果为671-8，运算结果为663
./captcha_verify/186-92乘8.png的识别结果为92*8，运算结果为736
./captcha_verify/187-6除以916.png的识别结果为6/916，运算结果为0.006550218340611353
./captcha_verify/188-7加8.png的识别结果为7+8，运算结果为15
./captcha_verify/189-6加3.png的识别结果为6+3，运算结果为9
./captcha_verify/19-68乘8.png的识别结果为68*8，运算结果为544
./captcha_verify/190-840加380.png图片处理失败
./captcha_verify/191-3加903.png图片处理失败
./captcha_verify/192-804减99.png图片处理失败
./captcha_verify/193-71减10.png的识别结果为71-10，运算结果为61
./captcha_verify/194-824加493.png的识别结果为824+493，运算结果为1317
./captcha_verify/195-4减62.png的识别结果为4-62，运算结果为-58
./captcha_verify/196-2乘33.png的识别结果为2*33，运算结果为66
./captcha_verify/197-93加1.png的识别结果为93+1，运算结果为94
./captcha_verify/198-1除以30.png的识别结果为1/30，运算结果为0.03333333333333333
./captcha_verify/199-84减454.png的识别结果为84-454，运算结果为-370
./captcha_verify/2-164乘77.png的识别结果为164*77，运算结果为12628
./captcha_verify/20-17乘62.png的识别结果为17*62，运算结果为1054
./captcha_verify/200-8除以7.png的识别结果为8/7，运算结果为1.1428571428571428
./captcha_verify/201-18加295.png的识别结果为18+295，运算结果为313
./captcha_verify/202-90减844.png图片处理失败
./captcha_verify/203-37除以3.png的识别结果为37/3，运算结果为12.333333333333334
./captcha_verify/204-436减10.png的识别结果为436-10，运算结果为426
./captcha_verify/205-967乘74.png的识别结果为967*74，运算结果为71558
./captcha_verify/206-0除以1.png的识别结果为0/1，运算结果为0.0
./captcha_verify/207-37除以174.png的识别结果为37/174，运算结果为0.21264367816091953
./captcha_verify/208-590除以3.png的识别结果为590/3，运算结果为196.66666666666666
./captcha_verify/209-20乘387.png的识别结果为20*387，运算结果为7740
./captcha_verify/21-105除以3.png的识别结果为105/3，运算结果为35.0
./captcha_verify/210-3除以457.png的识别结果为3/457，运算结果为0.006564551422319475
./captcha_verify/211-6减82.png的识别结果为6-82，运算结果为-76
./captcha_verify/212-4乘175.png的识别结果为4*175，运算结果为700
./captcha_verify/213-23除以10.png的识别结果为23/10，运算结果为2.3
./captcha_verify/214-7加15.png的识别结果为7+15，运算结果为22
./captcha_verify/215-57乘58.png的识别结果为57*58，运算结果为3306
./captcha_verify/216-914除以97.png的识别结果为914/97，运算结果为9.422680412371134
./captcha_verify/217-238减544.png图片处理失败
./captcha_verify/218-4乘468.png的识别结果为4*468，运算结果为1872
./captcha_verify/219-4除以9.png的识别结果为4/9，运算结果为0.4444444444444444
./captcha_verify/22-1除以55.png的识别结果为1/55，运算结果为0.01818181818181818
./captcha_verify/220-759加654.png的识别结果为759+654，运算结果为1413
./captcha_verify/221-691乘82.png的识别结果为691*82，运算结果为56662
./captcha_verify/222-5减6.png的识别结果为5-6，运算结果为-1
./captcha_verify/223-29除以313.png图片处理失败
./captcha_verify/224-561减7.png的识别结果为561-7，运算结果为554
./captcha_verify/225-2加395.png的识别结果为2+395，运算结果为397
./captcha_verify/226-49除以168.png的识别结果为49/168，运算结果为0.2916666666666667
./captcha_verify/227-65加969.png的识别结果为65+969，运算结果为1034
./captcha_verify/228-45乘464.png的识别结果为45*464，运算结果为20880
./captcha_verify/229-809乘7.png的识别结果为809*7，运算结果为5663
./captcha_verify/23-843乘244.png的识别结果为843*244，运算结果为205692
./captcha_verify/230-67除以70.png的识别结果为67/70，运算结果为0.9571428571428572
./captcha_verify/231-7乘31.png的识别结果为7*31，运算结果为217
./captcha_verify/232-71减63.png的识别结果为71-63，运算结果为8
./captcha_verify/233-2除以48.png的识别结果为2/48，运算结果为0.041666666666666664
./captcha_verify/234-32减381.png的识别结果为32-381，运算结果为-349
./captcha_verify/235-31乘71.png的识别结果为31*71，运算结果为2201
./captcha_verify/236-358加96.png的识别结果为358*96，运算结果为34368
./captcha_verify/237-0除以757.png的识别结果为0/757，运算结果为0.0
./captcha_verify/238-7减8.png的识别结果为7-8，运算结果为-1
./captcha_verify/239-478减3.png的识别结果为478-3，运算结果为475
./captcha_verify/24-0加796.png的识别结果为0+796，运算结果为796
./captcha_verify/240-8减42.png的识别结果为8-42，运算结果为-34
./captcha_verify/241-640除以459.png的识别结果为640/459，运算结果为1.3943355119825709
./captcha_verify/242-702加502.png的识别结果为702+502，运算结果为1204
./captcha_verify/243-15加317.png的识别结果为15+317，运算结果为332
./captcha_verify/244-51乘761.png的识别结果为51*761，运算结果为38811
./captcha_verify/245-5除以93.png的识别结果为5/93，运算结果为0.053763440860215055
./captcha_verify/246-903加216.png的识别结果为903+216，运算结果为1119
./captcha_verify/247-49除以9.png的识别结果为49/9，运算结果为5.444444444444445
./captcha_verify/248-0减63.png的识别结果为0-63，运算结果为-63
./captcha_verify/249-329加7.png的识别结果为329+7，运算结果为336
./captcha_verify/25-758乘2.png的识别结果为758*2，运算结果为1516
./captcha_verify/250-69加5.png的识别结果为69+5，运算结果为74
./captcha_verify/251-0乘37.png的识别结果为0*37，运算结果为0
./captcha_verify/252-2乘271.png的识别结果为2*271，运算结果为542
./captcha_verify/253-529减986.png的识别结果为529-986，运算结果为-457
./captcha_verify/254-91加82.png的识别结果为91+82，运算结果为173
./captcha_verify/255-748加29.png的识别结果为748+29，运算结果为777
./captcha_verify/256-9减105.png的识别结果为9-105，运算结果为-96
./captcha_verify/257-846减10.png的识别结果为846-10，运算结果为836
./captcha_verify/258-29减539.png的识别结果为29-539，运算结果为-510
./captcha_verify/259-71乘386.png的识别结果为71*386，运算结果为27406
./captcha_verify/26-1加4.png的识别结果为1+4，运算结果为5
./captcha_verify/260-64减41.png图片处理失败
./captcha_verify/261-5除以74.png的识别结果为5/74，运算结果为0.06756756756756757
./captcha_verify/262-0加919.png的识别结果为0+919，运算结果为919
./captcha_verify/263-0加430.png的识别结果为0+430，运算结果为430
./captcha_verify/264-57减9.png的识别结果为57-9，运算结果为48
./captcha_verify/265-64加618.png的识别结果为64+618，运算结果为682
./captcha_verify/266-30除以61.png图片处理失败
./captcha_verify/267-7减59.png的识别结果为7-59，运算结果为-52
./captcha_verify/268-3减15.png的识别结果为3-15，运算结果为-12
./captcha_verify/269-19加70.png的识别结果为19+70，运算结果为89
./captcha_verify/27-3除以39.png的识别结果为3/39，运算结果为0.07692307692307693
./captcha_verify/270-48减2.png的识别结果为48-2，运算结果为46
./captcha_verify/271-415乘6.png的识别结果为415*6，运算结果为2490
./captcha_verify/272-1加9.png的识别结果为1+9，运算结果为10
./captcha_verify/273-8乘11.png的识别结果为8*11，运算结果为88
./captcha_verify/274-1加8.png的识别结果为1+8，运算结果为9
./captcha_verify/275-38加93.png的识别结果为38+93，运算结果为131
./captcha_verify/276-5除以622.png的识别结果为5/622，运算结果为0.008038585209003215
./captcha_verify/277-9乘51.png的识别结果为9*51，运算结果为459
./captcha_verify/278-803加952.png的识别结果为803+952，运算结果为1755
./captcha_verify/279-9加38.png的识别结果为9+38，运算结果为47
./captcha_verify/28-35加79.png的识别结果为35+79，运算结果为114
./captcha_verify/280-287减2.png的识别结果为287-2，运算结果为285
./captcha_verify/281-198乘763.png的识别结果为198*763，运算结果为151074
./captcha_verify/282-724除以7.png的识别结果为724/7，运算结果为103.42857142857143
./captcha_verify/283-13加26.png的识别结果为13+26，运算结果为39
./captcha_verify/284-586乘8.png图片处理失败
./captcha_verify/285-1加10.png的识别结果为1+10，运算结果为11
./captcha_verify/286-390加694.png图片处理失败
./captcha_verify/287-92加39.png的识别结果为92+39，运算结果为131
./captcha_verify/288-706乘50.png的识别结果为706*50，运算结果为35300
./captcha_verify/289-8乘249.png的识别结果为8*249，运算结果为1992
./captcha_verify/29-241乘5.png的识别结果为241*5，运算结果为1205
./captcha_verify/290-71减1.png的识别结果为71-1，运算结果为70
./captcha_verify/291-7加2.png的识别结果为7+2，运算结果为9
./captcha_verify/292-4减47.png的识别结果为4-47，运算结果为-43
./captcha_verify/293-9乘542.png的识别结果为9*542，运算结果为4878
./captcha_verify/294-63减82.png的识别结果为63-82，运算结果为-19
./captcha_verify/295-730加14.png的识别结果为730+14，运算结果为744
./captcha_verify/296-71除以9.png的识别结果为71/9，运算结果为7.888888888888889
./captcha_verify/297-208除以7.png的识别结果为208/7，运算结果为29.714285714285715
./captcha_verify/298-756减51.png的识别结果为756-51，运算结果为705
./captcha_verify/299-50乘6.png的识别结果为50*6，运算结果为300
./captcha_verify/3-89加3.png的识别结果为89+3，运算结果为92
./captcha_verify/30-70乘84.png的识别结果为70*84，运算结果为5880
./captcha_verify/300-62减92.png的识别结果为62-92，运算结果为-30
./captcha_verify/301-239减294.png的识别结果为239-294，运算结果为-55
./captcha_verify/302-93减1.png的识别结果为93-1，运算结果为92
./captcha_verify/303-318减66.png的识别结果为318-66，运算结果为252
./captcha_verify/304-48除以6.png的识别结果为48/6，运算结果为8.0
./captcha_verify/305-65减457.png的识别结果为65-457，运算结果为-392
./captcha_verify/306-65除以7.png的识别结果为65/7，运算结果为9.285714285714286
./captcha_verify/307-38乘979.png的识别结果为38*979，运算结果为37202
./captcha_verify/308-13乘59.png的识别结果为13*59，运算结果为767
./captcha_verify/309-307加9.png的识别结果为307+9，运算结果为316
./captcha_verify/31-69除以6.png的识别结果为69/6，运算结果为11.5
./captcha_verify/310-5加908.png的识别结果为5+908，运算结果为913
./captcha_verify/311-3加61.png的识别结果为3+61，运算结果为64
./captcha_verify/312-3除以411.png的识别结果为3/411，运算结果为0.0072992700729927005
./captcha_verify/313-2乘898.png的识别结果为2*898，运算结果为1796
./captcha_verify/314-823减2.png的识别结果为823-2，运算结果为821
./captcha_verify/315-1减622.png的识别结果为1-622，运算结果为-621
./captcha_verify/316-9加38.png的识别结果为9+38，运算结果为47
./captcha_verify/317-1减5.png的识别结果为1-5，运算结果为-4
./captcha_verify/318-75减98.png的识别结果为75-98，运算结果为-23
./captcha_verify/319-51除以938.png的识别结果为51/938，运算结果为0.054371002132196165
./captcha_verify/32-514乘8.png的识别结果为514*8，运算结果为4112
./captcha_verify/320-0减2.png的识别结果为0-2，运算结果为-2
./captcha_verify/321-24除以73.png的识别结果为24/73，运算结果为0.3287671232876712
./captcha_verify/322-36除以505.png的识别结果为36/505，运算结果为0.07128712871287128
./captcha_verify/323-34乘7.png图片处理失败
./captcha_verify/324-37加2.png的识别结果为37+2，运算结果为39
./captcha_verify/325-1除以491.png的识别结果为1/491，运算结果为0.002036659877800407
./captcha_verify/326-809减2.png的识别结果为809-2，运算结果为807
./captcha_verify/327-56乘6.png的识别结果为56*6，运算结果为336
./captcha_verify/328-8乘87.png的识别结果为8*87，运算结果为696
./captcha_verify/329-9除以761.png的识别结果为9/761，运算结果为0.011826544021024968
./captcha_verify/33-6乘50.png的识别结果为6*50，运算结果为300
./captcha_verify/330-32加2.png的识别结果为32+2，运算结果为34
./captcha_verify/331-361减60.png的识别结果为361-60，运算结果为301
./captcha_verify/332-25除以18.png的识别结果为25/18，运算结果为1.3888888888888888
./captcha_verify/333-1除以6.png的识别结果为1/6，运算结果为0.16666666666666666
./captcha_verify/334-538乘926.png的识别结果为538*926，运算结果为498188
./captcha_verify/335-793加3.png的识别结果为793+3，运算结果为796
./captcha_verify/336-24加85.png的识别结果为24+85，运算结果为109
./captcha_verify/337-824减550.png的识别结果为824-550，运算结果为274
./captcha_verify/338-7乘160.png的识别结果为7*160，运算结果为1120
./captcha_verify/339-72减5.png的识别结果为72-5，运算结果为67
./captcha_verify/34-427除以3.png的识别结果为427/3，运算结果为142.33333333333334
./captcha_verify/340-4乘17.png的识别结果为4*17，运算结果为68
./captcha_verify/341-9加133.png的识别结果为9+133，运算结果为142
./captcha_verify/342-53加476.png的识别结果为53+476，运算结果为529
./captcha_verify/343-68除以244.png的识别结果为68/244，运算结果为0.2786885245901639
./captcha_verify/344-385除以5.png的识别结果为385/5，运算结果为77.0
./captcha_verify/345-736乘1.png的识别结果为736*1，运算结果为736
./captcha_verify/346-216乘10.png图片处理失败
./captcha_verify/347-27除以65.png的识别结果为27/65，运算结果为0.4153846153846154
./captcha_verify/348-6加110.png的识别结果为6+110，运算结果为116
./captcha_verify/349-465乘5.png的识别结果为465*5，运算结果为2325
./captcha_verify/35-0乘66.png的识别结果为0*66，运算结果为0
./captcha_verify/350-8加876.png的识别结果为8+876，运算结果为884
./captcha_verify/351-0减150.png的识别结果为0-150，运算结果为-150
./captcha_verify/352-72除以43.png的识别结果为72/43，运算结果为1.6744186046511629
./captcha_verify/353-38加655.png的识别结果为38+655，运算结果为693
./captcha_verify/354-195减1.png的识别结果为195-1，运算结果为194
./captcha_verify/355-8除以82.png的识别结果为8/82，运算结果为0.0975609756097561
./captcha_verify/356-2加651.png的识别结果为2+651，运算结果为653
./captcha_verify/357-14加6.png的识别结果为14+6，运算结果为20
./captcha_verify/358-76减10.png的识别结果为76-10，运算结果为66
./captcha_verify/359-4乘10.png的识别结果为4*10，运算结果为40
./captcha_verify/36-7加3.png的识别结果为7+3，运算结果为10
./captcha_verify/360-349除以3.png的识别结果为349/3，运算结果为116.33333333333333
./captcha_verify/361-59减96.png的识别结果为59-96，运算结果为-37
./captcha_verify/362-83加6.png的识别结果为83+6，运算结果为89
./captcha_verify/363-50除以48.png的识别结果为50/48，运算结果为1.0416666666666667
./captcha_verify/364-105除以16.png的识别结果为105/16，运算结果为6.5625
./captcha_verify/365-39乘9.png的识别结果为39*9，运算结果为351
./captcha_verify/366-194乘3.png的识别结果为194*3，运算结果为582
./captcha_verify/367-3除以76.png的识别结果为3/76，运算结果为0.039473684210526314
./captcha_verify/368-61减4.png的识别结果为61-4，运算结果为57
./captcha_verify/369-12乘13.png的识别结果为12*13，运算结果为156
./captcha_verify/37-31减2.png的识别结果为31-2，运算结果为29
./captcha_verify/370-150除以32.png的识别结果为150/32，运算结果为4.6875
./captcha_verify/371-94乘95.png图片处理失败
./captcha_verify/372-517乘17.png的识别结果为517*17，运算结果为8789
./captcha_verify/373-1减3.png的识别结果为1-3，运算结果为-2
./captcha_verify/374-6除以40.png的识别结果为6/40，运算结果为0.15
./captcha_verify/375-238乘5.png的识别结果为238*5，运算结果为1190
./captcha_verify/376-9乘9.png的识别结果为9*9，运算结果为81
./captcha_verify/377-9除以680.png的识别结果为9/680，运算结果为0.013235294117647059
./captcha_verify/378-62加35.png的识别结果为62+35，运算结果为97
./captcha_verify/379-376减408.png的识别结果为376-408，运算结果为-32
./captcha_verify/38-3乘198.png的识别结果为3*198，运算结果为594
./captcha_verify/380-983乘79.png的识别结果为983*79，运算结果为77657
./captcha_verify/381-73除以1.png的识别结果为73/1，运算结果为73.0
./captcha_verify/382-4乘5.png的识别结果为4*5，运算结果为20
./captcha_verify/383-78减93.png的识别结果为78-93，运算结果为-15
./captcha_verify/384-24加10.png的识别结果为24+10，运算结果为34
./captcha_verify/385-3加60.png的识别结果为3+60，运算结果为63
./captcha_verify/386-70除以483.png的识别结果为70/483，运算结果为0.14492753623188406
./captcha_verify/387-3减518.png的识别结果为3-518，运算结果为-515
./captcha_verify/388-8加330.png的识别结果为8+330，运算结果为338
./captcha_verify/389-4除以3.png的识别结果为4/3，运算结果为1.3333333333333333
./captcha_verify/39-8减3.png的识别结果为8-3，运算结果为5
./captcha_verify/390-17乘51.png的识别结果为17*51，运算结果为867
./captcha_verify/391-56乘715.png的识别结果为56*715，运算结果为40040
./captcha_verify/392-50乘5.png的识别结果为50*5，运算结果为250
./captcha_verify/393-379加5.png的识别结果为379+5，运算结果为384
./captcha_verify/394-4加362.png的识别结果为4+362，运算结果为366
./captcha_verify/395-4乘828.png的识别结果为4*828，运算结果为3312
./captcha_verify/396-410加30.png的识别结果为410+30，运算结果为440
./captcha_verify/397-2加1.png的识别结果为2+1，运算结果为3
./captcha_verify/398-2乘75.png的识别结果为2*75，运算结果为150
./captcha_verify/399-893减75.png的识别结果为893-75，运算结果为818
./captcha_verify/4-59除以10.png的识别结果为59/10，运算结果为5.9
./captcha_verify/40-0减3.png的识别结果为0-3，运算结果为-3
./captcha_verify/400-50减25.png的识别结果为50-25，运算结果为25
./captcha_verify/401-3除以32.png的识别结果为3/32，运算结果为0.09375
./captcha_verify/402-972减58.png的识别结果为972-58，运算结果为914
./captcha_verify/403-7乘10.png的识别结果为7*10，运算结果为70
./captcha_verify/404-4减64.png的识别结果为4-64，运算结果为-60
./captcha_verify/405-548除以490.png的识别结果为548/490，运算结果为1.1183673469387756
./captcha_verify/406-3加10.png的识别结果为3+10，运算结果为13
./captcha_verify/407-5加35.png的识别结果为5+35，运算结果为40
./captcha_verify/408-45乘7.png的识别结果为45*7，运算结果为315
./captcha_verify/409-24乘1.png的识别结果为24*1，运算结果为24
./captcha_verify/41-2加92.png的识别结果为2+92，运算结果为94
./captcha_verify/410-2乘1.png的识别结果为2*1，运算结果为2
./captcha_verify/411-8加4.png的识别结果为8+4，运算结果为12
./captcha_verify/412-498乘19.png的识别结果为498*19，运算结果为9462
./captcha_verify/413-829乘128.png的识别结果为829*128，运算结果为106112
./captcha_verify/414-5加3.png的识别结果为5+3，运算结果为8
./captcha_verify/415-6乘32.png的识别结果为6*32，运算结果为192
./captcha_verify/416-2乘963.png的识别结果为2*963，运算结果为1926
./captcha_verify/417-298减29.png的识别结果为298-29，运算结果为269
./captcha_verify/418-4加1.png的识别结果为4+1，运算结果为5
./captcha_verify/419-9乘4.png的识别结果为9*4，运算结果为36
./captcha_verify/42-3乘5.png的识别结果为3*5，运算结果为15
./captcha_verify/420-17乘16.png的识别结果为17*16，运算结果为272
./captcha_verify/421-26减183.png的识别结果为26-183，运算结果为-157
./captcha_verify/422-43减646.png的识别结果为43-646，运算结果为-603
./captcha_verify/423-789乘477.png图片处理失败
./captcha_verify/424-80乘420.png的识别结果为80*420，运算结果为33600
./captcha_verify/425-4乘80.png的识别结果为4*80，运算结果为320
./captcha_verify/426-83减57.png的识别结果为83-57，运算结果为26
./captcha_verify/427-7乘55.png的识别结果为7*55，运算结果为385
./captcha_verify/428-9加969.png的识别结果为9+969，运算结果为978
./captcha_verify/429-690乘975.png的识别结果为690*975，运算结果为672750
./captcha_verify/43-9乘759.png的识别结果为9*759，运算结果为6831
./captcha_verify/430-7除以3.png的识别结果为7/3，运算结果为2.3333333333333335
./captcha_verify/431-19除以10.png的识别结果为19/10，运算结果为1.9
./captcha_verify/432-1加59.png的识别结果为1+59，运算结果为60
./captcha_verify/433-517减6.png的识别结果为517-6，运算结果为511
./captcha_verify/434-7乘55.png的识别结果为7*55，运算结果为385
./captcha_verify/435-90乘9.png的识别结果为90*9，运算结果为810
./captcha_verify/436-78乘807.png的识别结果为78*807，运算结果为62946
./captcha_verify/437-24除以5.png的识别结果为24/5，运算结果为4.8
./captcha_verify/438-14乘20.png的识别结果为14*20，运算结果为280
./captcha_verify/439-460乘7.png的识别结果为460*7，运算结果为3220
./captcha_verify/44-93加891.png的识别结果为93+891，运算结果为984
./captcha_verify/440-7乘2.png的识别结果为7*2，运算结果为14
./captcha_verify/441-35加1.png的识别结果为35+1，运算结果为36
./captcha_verify/442-3乘57.png的识别结果为3*57，运算结果为171
./captcha_verify/443-21减36.png的识别结果为21-36，运算结果为-15
./captcha_verify/444-812乘10.png的识别结果为812*10，运算结果为8120
./captcha_verify/445-478加21.png的识别结果为478+21，运算结果为499
./captcha_verify/446-7除以30.png的识别结果为7/30，运算结果为0.23333333333333334
./captcha_verify/447-89乘747.png的识别结果为89*747，运算结果为66483
./captcha_verify/448-51加54.png图片处理失败
./captcha_verify/449-12乘3.png的识别结果为12*3，运算结果为36
./captcha_verify/45-5除以540.png图片处理失败
./captcha_verify/450-748乘10.png的识别结果为748*10，运算结果为7480
./captcha_verify/451-5除以4.png的识别结果为5/4，运算结果为1.25
./captcha_verify/452-7乘807.png的识别结果为7*807，运算结果为5649
./captcha_verify/453-3加8.png的识别结果为3+8，运算结果为11
./captcha_verify/454-79除以9.png的识别结果为79/9，运算结果为8.777777777777779
./captcha_verify/455-65除以4.png的识别结果为65/4，运算结果为16.25
./captcha_verify/456-96乘90.png的识别结果为96*90，运算结果为8640
./captcha_verify/457-739加85.png的识别结果为739+85，运算结果为824
./captcha_verify/458-1减330.png的识别结果为1-330，运算结果为-329
./captcha_verify/459-19减24.png的识别结果为19-24，运算结果为-5
./captcha_verify/46-19加69.png的识别结果为19+69，运算结果为88
./captcha_verify/460-297加214.png的识别结果为297+214，运算结果为511
./captcha_verify/461-871乘92.png的识别结果为871*92，运算结果为80132
./captcha_verify/462-249除以8.png的识别结果为249/8，运算结果为31.125
./captcha_verify/463-12减183.png的识别结果为12-183，运算结果为-171
./captcha_verify/464-69除以17.png的识别结果为69/17，运算结果为4.0588235294117645
./captcha_verify/465-4乘6.png的识别结果为4*6，运算结果为24
./captcha_verify/466-218减9.png的识别结果为218-9，运算结果为209
./captcha_verify/467-0减86.png的识别结果为0-86，运算结果为-86
./captcha_verify/468-9乘97.png的识别结果为9*97，运算结果为873
./captcha_verify/469-41减766.png的识别结果为41-766，运算结果为-725
./captcha_verify/47-8乘26.png的识别结果为8*26，运算结果为208
./captcha_verify/470-93减8.png的识别结果为93-8，运算结果为85
./captcha_verify/471-95乘38.png的识别结果为95*38，运算结果为3610
./captcha_verify/472-681加408.png的识别结果为681+408，运算结果为1089
./captcha_verify/473-82加79.png的识别结果为82+79，运算结果为161
./captcha_verify/474-85加73.png的识别结果为85+73，运算结果为158
./captcha_verify/475-9加655.png的识别结果为9+655，运算结果为664
./captcha_verify/476-90乘48.png的识别结果为90*48，运算结果为4320
./captcha_verify/477-53乘688.png的识别结果为53*688，运算结果为36464
./captcha_verify/478-76减2.png的识别结果为76-2，运算结果为74
./captcha_verify/479-3加8.png的识别结果为3+8，运算结果为11
./captcha_verify/48-52乘30.png的识别结果为52*30，运算结果为1560
./captcha_verify/480-71减9.png的识别结果为71-9，运算结果为62
./captcha_verify/481-5加27.png的识别结果为5+27，运算结果为32
./captcha_verify/482-21减9.png的识别结果为21-9，运算结果为12
./captcha_verify/483-3加90.png的识别结果为3+90，运算结果为93
./captcha_verify/484-24减4.png的识别结果为24-4，运算结果为20
./captcha_verify/485-634除以539.png图片处理失败
./captcha_verify/486-98减404.png的识别结果为98-404，运算结果为-306
./captcha_verify/487-4加651.png的识别结果为4+651，运算结果为655
./captcha_verify/488-206加22.png的识别结果为206+22，运算结果为228
./captcha_verify/489-95乘47.png的识别结果为95*47，运算结果为4465
./captcha_verify/49-567加1.png的识别结果为567+1，运算结果为568
./captcha_verify/490-581加731.png的识别结果为581+731，运算结果为1312
./captcha_verify/491-185加93.png的识别结果为185+93，运算结果为278
./captcha_verify/492-6除以648.png的识别结果为6/648，运算结果为0.009259259259259259
./captcha_verify/493-915加52.png的识别结果为915+52，运算结果为967
./captcha_verify/494-219加104.png的识别结果为219+104，运算结果为323
./captcha_verify/495-516乘8.png的识别结果为516*8，运算结果为4128
./captcha_verify/496-79减26.png的识别结果为79-26，运算结果为53
./captcha_verify/497-3除以14.png的识别结果为3/14，运算结果为0.21428571428571427
./captcha_verify/498-73加9.png的识别结果为73+9，运算结果为82
./captcha_verify/499-5除以65.png的识别结果为5/65，运算结果为0.07692307692307693
./captcha_verify/5-69加1.png的识别结果为69+1，运算结果为70
./captcha_verify/50-9加25.png的识别结果为9+25，运算结果为34
./captcha_verify/500-34除以6.png的识别结果为34/6，运算结果为5.666666666666667
./captcha_verify/501-69加520.png的识别结果为69+520，运算结果为589
./captcha_verify/502-430乘8.png的识别结果为430*8，运算结果为3440
./captcha_verify/503-3减54.png的识别结果为3-54，运算结果为-51
./captcha_verify/504-1乘9.png的识别结果为1*9，运算结果为9
./captcha_verify/505-7加252.png的识别结果为7+252，运算结果为259
./captcha_verify/506-653除以8.png的识别结果为653/8，运算结果为81.625
./captcha_verify/507-52除以3.png的识别结果为52/3，运算结果为17.333333333333332
./captcha_verify/508-209减7.png的识别结果为209-7，运算结果为202
./captcha_verify/509-9加363.png的识别结果为9+363，运算结果为372
./captcha_verify/51-597除以82.png的识别结果为597/82，运算结果为7.280487804878049
./captcha_verify/510-4减1.png的识别结果为4-1，运算结果为3
./captcha_verify/511-8除以2.png的识别结果为8/2，运算结果为4.0
./captcha_verify/512-3加2.png的识别结果为3+2，运算结果为5
./captcha_verify/513-253除以805.png的识别结果为253/805，运算结果为0.3142857142857143
./captcha_verify/514-894乘399.png的识别结果为894*399，运算结果为356706
./captcha_verify/515-816减84.png的识别结果为816-84，运算结果为732
./captcha_verify/516-6加11.png的识别结果为6+11，运算结果为17
./captcha_verify/517-83除以438.png的识别结果为83/438，运算结果为0.18949771689497716
./captcha_verify/518-862乘8.png的识别结果为862*8，运算结果为6896
./captcha_verify/519-72除以92.png的识别结果为72/92，运算结果为0.782608695652174
./captcha_verify/52-71除以38.png的识别结果为71/38，运算结果为1.868421052631579
./captcha_verify/520-527加387.png的识别结果为527+387，运算结果为914
./captcha_verify/521-65除以6.png的识别结果为65/6，运算结果为10.833333333333334
./captcha_verify/522-4加6.png的识别结果为4+6，运算结果为10
./captcha_verify/523-427加54.png的识别结果为427+54，运算结果为481
./captcha_verify/524-2乘10.png的识别结果为2*10，运算结果为20
./captcha_verify/525-3乘14.png图片处理失败
./captcha_verify/526-679加572.png的识别结果为679+572，运算结果为1251
./captcha_verify/527-736除以562.png的识别结果为736/562，运算结果为1.309608540925267
./captcha_verify/528-874加5.png的识别结果为874+5，运算结果为879
./captcha_verify/529-5减1.png的识别结果为5-1，运算结果为4
./captcha_verify/53-86加30.png的识别结果为86+30，运算结果为116
./captcha_verify/530-1除以98.png的识别结果为1/98，运算结果为0.01020408163265306
./captcha_verify/531-3加8.png的识别结果为3+8，运算结果为11
./captcha_verify/532-26减85.png的识别结果为26-85，运算结果为-59
./captcha_verify/533-84加61.png图片处理失败
./captcha_verify/534-6减732.png的识别结果为6-732，运算结果为-726
./captcha_verify/535-21加68.png的识别结果为21+68，运算结果为89
./captcha_verify/536-4乘60.png的识别结果为4*60，运算结果为240
./captcha_verify/537-9减9.png的识别结果为9-9，运算结果为0
./captcha_verify/538-12乘1.png的识别结果为12*1，运算结果为12
./captcha_verify/539-0除以974.png图片处理失败
./captcha_verify/54-89加44.png的识别结果为89+44，运算结果为133
./captcha_verify/540-65加9.png的识别结果为65+9，运算结果为74
./captcha_verify/541-78乘851.png的识别结果为78*851，运算结果为66378
./captcha_verify/542-9加733.png的识别结果为9+733，运算结果为742
./captcha_verify/543-51除以848.png的识别结果为51/848，运算结果为0.060141509433962265
./captcha_verify/544-891加1.png的识别结果为891+1，运算结果为892
./captcha_verify/545-401除以6.png图片处理失败
./captcha_verify/546-508减422.png的识别结果为508-422，运算结果为86
./captcha_verify/547-8减58.png的识别结果为8-58，运算结果为-50
./captcha_verify/548-12加597.png的识别结果为12+597，运算结果为609
./captcha_verify/549-8乘8.png的识别结果为8*8，运算结果为64
./captcha_verify/55-0除以33.png的识别结果为0/33，运算结果为0.0
./captcha_verify/550-47加3.png的识别结果为47+3，运算结果为50
./captcha_verify/551-689加2.png的识别结果为689+2，运算结果为691
./captcha_verify/552-425乘616.png的识别结果为425*616，运算结果为261800
./captcha_verify/553-724乘7.png的识别结果为724*7，运算结果为5068
./captcha_verify/554-4减53.png的识别结果为4-53，运算结果为-49
./captcha_verify/555-482加104.png的识别结果为482+104，运算结果为586
./captcha_verify/556-0加5.png的识别结果为0+5，运算结果为5
./captcha_verify/557-3乘5.png的识别结果为3*5，运算结果为15
./captcha_verify/558-62减971.png的识别结果为62-971，运算结果为-909
./captcha_verify/559-7加9.png的识别结果为7+9，运算结果为16
./captcha_verify/56-1加55.png的识别结果为1+55，运算结果为56
./captcha_verify/560-80减183.png的识别结果为80-183，运算结果为-103
./captcha_verify/561-152除以298.png的识别结果为152/298，运算结果为0.5100671140939598
./captcha_verify/562-3乘7.png的识别结果为3*7，运算结果为21
./captcha_verify/563-2除以766.png的识别结果为2/766，运算结果为0.0026109660574412533
./captcha_verify/564-908减74.png的识别结果为908-74，运算结果为834
./captcha_verify/565-401减77.png的识别结果为401-77，运算结果为324
./captcha_verify/566-0减14.png的识别结果为0-14，运算结果为-14
./captcha_verify/567-17加3.png的识别结果为17+3，运算结果为20
./captcha_verify/568-4除以16.png的识别结果为4/16，运算结果为0.25
./captcha_verify/569-86除以103.png的识别结果为86/103，运算结果为0.8349514563106796
./captcha_verify/57-684加525.png的识别结果为684+525，运算结果为1209
./captcha_verify/570-859乘38.png图片处理失败
./captcha_verify/571-35乘82.png的识别结果为35*82，运算结果为2870
./captcha_verify/572-7减972.png的识别结果为7-972，运算结果为-965
./captcha_verify/573-509除以821.png的识别结果为509/821，运算结果为0.6199756394640682
./captcha_verify/574-8减463.png的识别结果为8-463，运算结果为-455
./captcha_verify/575-421减32.png图片处理失败
./captcha_verify/576-1加71.png的识别结果为1+71，运算结果为72
./captcha_verify/577-149加5.png的识别结果为149+5，运算结果为154
./captcha_verify/578-5加69.png的识别结果为5+69，运算结果为74
./captcha_verify/579-93减8.png的识别结果为93-8，运算结果为85
./captcha_verify/58-59加32.png的识别结果为59+32，运算结果为91
./captcha_verify/580-27减793.png的识别结果为27-793，运算结果为-766
./captcha_verify/581-3加390.png的识别结果为3+390，运算结果为393
./captcha_verify/582-1除以590.png的识别结果为1/590，运算结果为0.001694915254237288
./captcha_verify/583-7减92.png的识别结果为7-92，运算结果为-85
./captcha_verify/584-69加870.png的识别结果为69+870，运算结果为939
./captcha_verify/585-0乘744.png的识别结果为0*744，运算结果为0
./captcha_verify/586-941除以376.png图片处理失败
./captcha_verify/587-80减568.png的识别结果为80-568，运算结果为-488
./captcha_verify/588-25除以5.png的识别结果为25/5，运算结果为5.0
./captcha_verify/589-7乘6.png的识别结果为7*6，运算结果为42
./captcha_verify/59-4除以421.png的识别结果为4/421，运算结果为0.009501187648456057
./captcha_verify/590-13除以7.png的识别结果为13/7，运算结果为1.8571428571428572
./captcha_verify/591-829减9.png的识别结果为829-9，运算结果为820
./captcha_verify/592-2乘9.png的识别结果为2*9，运算结果为18
./captcha_verify/593-48减61.png的识别结果为48-61，运算结果为-13
./captcha_verify/594-23除以70.png的识别结果为23/70，运算结果为0.32857142857142857
./captcha_verify/595-93减296.png的识别结果为93-296，运算结果为-203
./captcha_verify/596-982加86.png图片处理失败
./captcha_verify/597-70减36.png的识别结果为70-36，运算结果为34
./captcha_verify/598-768乘268.png的识别结果为768*268，运算结果为205824
./captcha_verify/599-5乘51.png的识别结果为5*51，运算结果为255
./captcha_verify/6-45除以68.png的识别结果为45/68，运算结果为0.6617647058823529
./captcha_verify/60-673除以139.png的识别结果为673/139，运算结果为4.841726618705036
./captcha_verify/600-27减82.png的识别结果为27-82，运算结果为-55
./captcha_verify/601-923除以27.png图片处理失败
./captcha_verify/602-5加702.png的识别结果为5+702，运算结果为707
./captcha_verify/603-71减4.png的识别结果为71-4，运算结果为67
./captcha_verify/604-109减5.png的识别结果为109-5，运算结果为104
./captcha_verify/605-3乘835.png的识别结果为3*835，运算结果为2505
./captcha_verify/606-8减1.png的识别结果为8-1，运算结果为7
./captcha_verify/607-8加21.png的识别结果为8+21，运算结果为29
./captcha_verify/608-1乘573.png的识别结果为1*573，运算结果为573
./captcha_verify/609-7加8.png的识别结果为7+8，运算结果为15
./captcha_verify/61-38乘622.png的识别结果为38*622，运算结果为23636
./captcha_verify/610-16加7.png的识别结果为16+7，运算结果为23
./captcha_verify/611-16乘37.png的识别结果为16*37，运算结果为592
./captcha_verify/612-87除以385.png的识别结果为87/385，运算结果为0.22597402597402597
./captcha_verify/613-0减4.png的识别结果为0-4，运算结果为-4
./captcha_verify/614-675除以6.png图片处理失败
./captcha_verify/615-759减10.png的识别结果为759-10，运算结果为749
./captcha_verify/616-4乘6.png的识别结果为4*6，运算结果为24
./captcha_verify/617-40减426.png的识别结果为40-426，运算结果为-386
./captcha_verify/618-572加2.png的识别结果为572+2，运算结果为574
./captcha_verify/619-564减9.png图片处理失败
./captcha_verify/62-23除以13.png的识别结果为23/13，运算结果为1.7692307692307692
./captcha_verify/620-75减7.png的识别结果为75-7，运算结果为68
./captcha_verify/621-9乘94.png的识别结果为9*94，运算结果为846
./captcha_verify/622-628除以903.png的识别结果为628/903，运算结果为0.6954595791805094
./captcha_verify/623-407加5.png的识别结果为407+5，运算结果为412
./captcha_verify/624-35加63.png的识别结果为35+63，运算结果为98
./captcha_verify/625-27乘3.png的识别结果为27*3，运算结果为81
./captcha_verify/626-190除以5.png的识别结果为190/5，运算结果为38.0
./captcha_verify/627-6减635.png的识别结果为6-635，运算结果为-629
./captcha_verify/628-912加270.png的识别结果为912+270，运算结果为1182
./captcha_verify/629-65加10.png的识别结果为65+10，运算结果为75
./captcha_verify/63-1乘175.png的识别结果为1*175，运算结果为175
./captcha_verify/630-172加7.png的识别结果为172+7，运算结果为179
./captcha_verify/631-1加24.png的识别结果为1+24，运算结果为25
./captcha_verify/632-680减490.png的识别结果为680-490，运算结果为190
./captcha_verify/633-60乘4.png的识别结果为60*4，运算结果为240
./captcha_verify/634-68除以7.png的识别结果为68/7，运算结果为9.714285714285714
./captcha_verify/635-617减80.png的识别结果为617-80，运算结果为537
./captcha_verify/636-8加44.png的识别结果为8+44，运算结果为52
./captcha_verify/637-349减40.png图片处理失败
./captcha_verify/638-3除以699.png的识别结果为3/699，运算结果为0.004291845493562232
./captcha_verify/639-49乘399.png的识别结果为49*399，运算结果为19551
./captcha_verify/64-7减750.png的识别结果为7-750，运算结果为-743
./captcha_verify/640-6乘99.png的识别结果为6*99，运算结果为594
./captcha_verify/641-6减76.png的识别结果为6-76，运算结果为-70
./captcha_verify/642-26乘37.png的识别结果为26*37，运算结果为962
./captcha_verify/643-5减64.png的识别结果为5-64，运算结果为-59
./captcha_verify/644-586乘73.png的识别结果为586*73，运算结果为42778
./captcha_verify/645-3减7.png的识别结果为3-7，运算结果为-4
./captcha_verify/646-4加590.png的识别结果为4+590，运算结果为594
./captcha_verify/647-729加290.png的识别结果为729+290，运算结果为1019
./captcha_verify/648-32加5.png的识别结果为32+5，运算结果为37
./captcha_verify/649-6除以94.png的识别结果为6/94，运算结果为0.06382978723404255
./captcha_verify/65-963乘5.png的识别结果为963*5，运算结果为4815
./captcha_verify/650-18加72.png的识别结果为18+72，运算结果为90
./captcha_verify/651-508减428.png的识别结果为508-428，运算结果为80
./captcha_verify/652-179减99.png的识别结果为179-99，运算结果为80
./captcha_verify/653-29除以237.png的识别结果为29/237，运算结果为0.12236286919831224
./captcha_verify/654-934加4.png的识别结果为934+4，运算结果为938
./captcha_verify/655-64加155.png图片处理失败
./captcha_verify/656-435除以986.png的识别结果为435/986，运算结果为0.4411764705882353
./captcha_verify/657-47减7.png的识别结果为47-7，运算结果为40
./captcha_verify/658-83除以91.png的识别结果为83/91，运算结果为0.9120879120879121
./captcha_verify/659-40除以672.png的识别结果为40/672，运算结果为0.05952380952380952
./captcha_verify/66-9乘258.png的识别结果为9*258，运算结果为2322
./captcha_verify/660-609乘31.png的识别结果为609*31，运算结果为18879
./captcha_verify/661-125加92.png的识别结果为125+92，运算结果为217
./captcha_verify/662-45除以432.png的识别结果为45/432，运算结果为0.10416666666666667
./captcha_verify/663-18除以99.png的识别结果为18/99，运算结果为0.18181818181818182
./captcha_verify/664-90除以4.png的识别结果为90/4，运算结果为22.5
./captcha_verify/665-891除以199.png的识别结果为891/199，运算结果为4.477386934673367
./captcha_verify/666-8除以10.png的识别结果为8/10，运算结果为0.8
./captcha_verify/667-164乘28.png的识别结果为164*28，运算结果为4592
./captcha_verify/668-3减9.png的识别结果为3-9，运算结果为-6
./captcha_verify/669-74加8.png的识别结果为74+8，运算结果为82
./captcha_verify/67-981除以5.png的识别结果为981/5，运算结果为196.2
./captcha_verify/670-794除以10.png的识别结果为794/10，运算结果为79.4
./captcha_verify/671-7加5.png的识别结果为7+5，运算结果为12
./captcha_verify/672-75乘68.png的识别结果为75*68，运算结果为5100
./captcha_verify/673-68减7.png的识别结果为68-7，运算结果为61
./captcha_verify/674-614乘8.png的识别结果为614*8，运算结果为4912
./captcha_verify/675-1加569.png的识别结果为1+569，运算结果为570
./captcha_verify/676-75加10.png的识别结果为75+10，运算结果为85
./captcha_verify/677-1减5.png的识别结果为1-5，运算结果为-4
./captcha_verify/678-5除以6.png图片处理失败
./captcha_verify/679-26加760.png的识别结果为26+760，运算结果为786
./captcha_verify/68-623加81.png的识别结果为623+81，运算结果为704
./captcha_verify/680-8加144.png的识别结果为8+144，运算结果为152
./captcha_verify/681-36除以16.png的识别结果为36/16，运算结果为2.25
./captcha_verify/682-75减547.png图片处理失败
./captcha_verify/683-50减7.png的识别结果为50-7，运算结果为43
./captcha_verify/684-67加85.png的识别结果为67+85，运算结果为152
./captcha_verify/685-96乘2.png的识别结果为96*2，运算结果为192
./captcha_verify/686-486乘541.png的识别结果为486*541，运算结果为262926
./captcha_verify/687-298乘97.png的识别结果为298*97，运算结果为28906
./captcha_verify/688-1减313.png的识别结果为1-313，运算结果为-312
./captcha_verify/689-56加38.png的识别结果为56+38，运算结果为94
./captcha_verify/69-7减16.png的识别结果为7-16，运算结果为-9
./captcha_verify/690-874除以9.png的识别结果为874/9，运算结果为97.11111111111111
./captcha_verify/691-50减9.png的识别结果为50-9，运算结果为41
./captcha_verify/692-76乘10.png的识别结果为76*10，运算结果为760
./captcha_verify/693-924除以72.png图片处理失败
./captcha_verify/694-2乘897.png的识别结果为2*897，运算结果为1794
./captcha_verify/695-571减5.png的识别结果为571-5，运算结果为566
./captcha_verify/696-48除以833.png的识别结果为48/833，运算结果为0.057623049219687875
./captcha_verify/697-150加95.png的识别结果为150+95，运算结果为245
./captcha_verify/698-4除以639.png的识别结果为4/639，运算结果为0.006259780907668232
./captcha_verify/699-563加18.png的识别结果为563+18，运算结果为581
./captcha_verify/7-3乘410.png的识别结果为3*410，运算结果为1230
./captcha_verify/70-49加10.png的识别结果为49+10，运算结果为59
./captcha_verify/700-83加8.png的识别结果为83+8，运算结果为91
./captcha_verify/701-1除以257.png的识别结果为1/257，运算结果为0.0038910505836575876
./captcha_verify/702-8除以840.png的识别结果为8/840，运算结果为0.009523809523809525
./captcha_verify/703-618除以783.png的识别结果为618/783，运算结果为0.789272030651341
./captcha_verify/704-596加362.png的识别结果为596+362，运算结果为958
./captcha_verify/705-64加6.png的识别结果为64+6，运算结果为70
./captcha_verify/706-31除以3.png的识别结果为31/3，运算结果为10.333333333333334
./captcha_verify/707-6加7.png的识别结果为6+7，运算结果为13
./captcha_verify/708-329加7.png的识别结果为329+7，运算结果为336
./captcha_verify/709-457乘94.png的识别结果为457*94，运算结果为42958
./captcha_verify/71-591减46.png的识别结果为591-46，运算结果为545
./captcha_verify/710-3乘988.png的识别结果为3*988，运算结果为2964
./captcha_verify/711-70除以87.png的识别结果为70/87，运算结果为0.8045977011494253
./captcha_verify/712-367乘74.png的识别结果为367*74，运算结果为27158
./captcha_verify/713-2乘55.png的识别结果为2*55，运算结果为110
./captcha_verify/714-409减6.png的识别结果为409-6，运算结果为403
./captcha_verify/715-208减5.png的识别结果为208-5，运算结果为203
./captcha_verify/716-98除以4.png的识别结果为98/4，运算结果为24.5
./captcha_verify/717-359减9.png的识别结果为359-9，运算结果为350
./captcha_verify/718-2乘11.png的识别结果为2*11，运算结果为22
./captcha_verify/719-13乘270.png的识别结果为13*270，运算结果为3510
./captcha_verify/72-643减636.png图片处理失败
./captcha_verify/720-473减66.png的识别结果为473-66，运算结果为407
./captcha_verify/721-6加76.png的识别结果为6+76，运算结果为82
./captcha_verify/722-802除以355.png的识别结果为802/355，运算结果为2.259154929577465
./captcha_verify/723-6加59.png的识别结果为6+59，运算结果为65
./captcha_verify/724-6加10.png的识别结果为6+10，运算结果为16
./captcha_verify/725-7加6.png的识别结果为7+6，运算结果为13
./captcha_verify/726-134加841.png图片处理失败
./captcha_verify/727-60乘46.png的识别结果为60-46，运算结果为14
./captcha_verify/728-872加649.png的识别结果为872+649，运算结果为1521
./captcha_verify/729-398减6.png的识别结果为398-6，运算结果为392
./captcha_verify/73-587减54.png的识别结果为587-54，运算结果为533
./captcha_verify/730-80减37.png的识别结果为80-37，运算结果为43
./captcha_verify/731-34减16.png的识别结果为34-16，运算结果为18
./captcha_verify/732-5乘75.png的识别结果为5*75，运算结果为375
./captcha_verify/733-6乘98.png的识别结果为6*98，运算结果为588
./captcha_verify/734-802加754.png图片处理失败
./captcha_verify/735-980加73.png的识别结果为980+73，运算结果为1053
./captcha_verify/736-53除以124.png的识别结果为53/124，运算结果为0.4274193548387097
./captcha_verify/737-6减10.png的识别结果为6-10，运算结果为-4
./captcha_verify/738-3除以99.png的识别结果为3/99，运算结果为0.030303030303030304
./captcha_verify/739-56乘88.png的识别结果为56*88，运算结果为4928
./captcha_verify/74-32减524.png的识别结果为32-524，运算结果为-492
./captcha_verify/740-15除以10.png的识别结果为15/10，运算结果为1.5
./captcha_verify/741-4加88.png的识别结果为4+88，运算结果为92
./captcha_verify/742-456除以3.png的识别结果为456/3，运算结果为152.0
./captcha_verify/743-673乘84.png图片处理失败
./captcha_verify/744-3加52.png的识别结果为3+52，运算结果为55
./captcha_verify/745-48乘6.png的识别结果为48*6，运算结果为288
./captcha_verify/746-47乘55.png的识别结果为47*55，运算结果为2585
./captcha_verify/747-614加410.png的识别结果为614+410，运算结果为1024
./captcha_verify/748-89除以7.png的识别结果为89/7，运算结果为12.714285714285714
./captcha_verify/749-9乘3.png的识别结果为9*3，运算结果为27
./captcha_verify/75-1乘5.png的识别结果为1*5，运算结果为5
./captcha_verify/750-17乘942.png的识别结果为17*942，运算结果为16014
./captcha_verify/751-52除以3.png的识别结果为52/3，运算结果为17.333333333333332
./captcha_verify/752-7加3.png的识别结果为7+3，运算结果为10
./captcha_verify/753-5乘3.png的识别结果为5*3，运算结果为15
./captcha_verify/754-9乘10.png的识别结果为9*10，运算结果为90
./captcha_verify/755-98加137.png的识别结果为98+137，运算结果为235
./captcha_verify/756-60加32.png的识别结果为60+32，运算结果为92
./captcha_verify/757-684乘26.png的识别结果为684*26，运算结果为17784
./captcha_verify/758-291除以3.png的识别结果为291/3，运算结果为97.0
./captcha_verify/759-0减31.png的识别结果为0-31，运算结果为-31
./captcha_verify/76-38乘46.png的识别结果为38*46，运算结果为1748
./captcha_verify/760-924乘544.png的识别结果为924*544，运算结果为502656
./captcha_verify/761-17减1.png的识别结果为17-1，运算结果为16
./captcha_verify/762-238除以9.png的识别结果为238/9，运算结果为26.444444444444443
./captcha_verify/763-348减28.png图片处理失败
./captcha_verify/764-7乘481.png的识别结果为7*481，运算结果为3367
./captcha_verify/765-90减211.png的识别结果为90-211，运算结果为-121
./captcha_verify/766-42加1.png的识别结果为42+1，运算结果为43
./captcha_verify/767-41乘14.png的识别结果为41*14，运算结果为574
./captcha_verify/768-1加954.png的识别结果为1+954，运算结果为955
./captcha_verify/769-14减328.png的识别结果为14-328，运算结果为-314
./captcha_verify/77-92加2.png的识别结果为92+2，运算结果为94
./captcha_verify/770-6减4.png的识别结果为6-4，运算结果为2
./captcha_verify/771-827加9.png的识别结果为827+9，运算结果为836
./captcha_verify/772-65乘206.png的识别结果为65*206，运算结果为13390
./captcha_verify/773-4加908.png的识别结果为4+908，运算结果为912
./captcha_verify/774-826乘17.png的识别结果为826*17，运算结果为14042
./captcha_verify/775-31加4.png的识别结果为31+4，运算结果为35
./captcha_verify/776-6除以10.png的识别结果为6/10，运算结果为0.6
./captcha_verify/777-0加2.png的识别结果为0+2，运算结果为2
./captcha_verify/778-24加1.png的识别结果为24+1，运算结果为25
./captcha_verify/779-52除以571.png图片处理失败
./captcha_verify/78-7加464.png图片处理失败
./captcha_verify/780-74乘35.png的识别结果为74*35，运算结果为2590
./captcha_verify/781-503乘486.png的识别结果为503*486，运算结果为244458
./captcha_verify/782-2减4.png的识别结果为2-4，运算结果为-2
./captcha_verify/783-5加7.png的识别结果为5+7，运算结果为12
./captcha_verify/784-598加14.png图片处理失败
./captcha_verify/785-5加264.png的识别结果为5+264，运算结果为269
./captcha_verify/786-3减518.png的识别结果为3-518，运算结果为-515
./captcha_verify/787-896减717.png的识别结果为896-717，运算结果为179
./captcha_verify/788-165加468.png的识别结果为165+468，运算结果为633
./captcha_verify/789-7除以62.png图片处理失败
./captcha_verify/79-548加37.png图片处理失败
./captcha_verify/790-1乘8.png的识别结果为1*8，运算结果为8
./captcha_verify/791-53减2.png的识别结果为53-2，运算结果为51
./captcha_verify/792-38除以43.png的识别结果为38/43，运算结果为0.8837209302325582
./captcha_verify/793-9减7.png的识别结果为9-7，运算结果为2
./captcha_verify/794-0加522.png的识别结果为0+522，运算结果为522
./captcha_verify/795-10除以2.png的识别结果为10/2，运算结果为5.0
./captcha_verify/796-26减2.png的识别结果为26-2，运算结果为24
./captcha_verify/797-57除以84.png的识别结果为57/84，运算结果为0.6785714285714286
./captcha_verify/798-5加290.png的识别结果为5+290，运算结果为295
./captcha_verify/799-6减1.png的识别结果为6-1，运算结果为5
./captcha_verify/8-961减41.png的识别结果为961-41，运算结果为920
./captcha_verify/80-12加459.png的识别结果为12+459，运算结果为471
./captcha_verify/800-365加51.png的识别结果为365+51，运算结果为416
./captcha_verify/801-412除以98.png的识别结果为412/98，运算结果为4.204081632653061
./captcha_verify/802-9乘65.png的识别结果为9*65，运算结果为585
./captcha_verify/803-3乘9.png的识别结果为3*9，运算结果为27
./captcha_verify/804-57减9.png的识别结果为57-9，运算结果为48
./captcha_verify/805-84除以36.png图片处理失败
./captcha_verify/806-0减954.png的识别结果为0-954，运算结果为-954
./captcha_verify/807-3乘316.png的识别结果为3*316，运算结果为948
./captcha_verify/808-629除以33.png的识别结果为629/33，运算结果为19.060606060606062
./captcha_verify/809-963乘5.png的识别结果为963*5，运算结果为4815
./captcha_verify/81-87加33.png的识别结果为87+33，运算结果为120
./captcha_verify/810-42加11.png的识别结果为42+11，运算结果为53
./captcha_verify/811-78乘904.png的识别结果为78*904，运算结果为70512
./captcha_verify/812-95除以26.png的识别结果为95/26，运算结果为3.6538461538461537
./captcha_verify/813-159减4.png的识别结果为159-4，运算结果为155
./captcha_verify/814-5加75.png的识别结果为5+75，运算结果为80
./captcha_verify/815-213减74.png的识别结果为213-74，运算结果为139
./captcha_verify/816-5减4.png的识别结果为5-4，运算结果为1
./captcha_verify/817-5除以33.png的识别结果为5/33，运算结果为0.15151515151515152
./captcha_verify/818-680加680.png的识别结果为680+680，运算结果为1360
./captcha_verify/819-73乘346.png图片处理失败
./captcha_verify/82-385减7.png的识别结果为385-7，运算结果为378
./captcha_verify/820-983除以707.png的识别结果为983/707，运算结果为1.3903818953323903
./captcha_verify/821-6乘30.png的识别结果为6*30，运算结果为180
./captcha_verify/822-952乘68.png的识别结果为952*68，运算结果为64736
./captcha_verify/823-4减138.png的识别结果为4-138，运算结果为-134
./captcha_verify/824-274乘44.png的识别结果为274*44，运算结果为12056
./captcha_verify/825-406加38.png的识别结果为406+38，运算结果为444
./captcha_verify/826-0除以76.png的识别结果为0/76，运算结果为0.0
./captcha_verify/827-19加864.png的识别结果为19+864，运算结果为883
./captcha_verify/828-23加95.png的识别结果为23+95，运算结果为118
./captcha_verify/829-1乘4.png的识别结果为1*4，运算结果为4
./captcha_verify/83-78除以54.png的识别结果为78/54，运算结果为1.4444444444444444
./captcha_verify/830-0加4.png的识别结果为0+4，运算结果为4
./captcha_verify/831-129除以2.png的识别结果为129/2，运算结果为64.5
./captcha_verify/832-53加2.png的识别结果为53+2，运算结果为55
./captcha_verify/833-9加544.png图片处理失败
./captcha_verify/834-84减94.png的识别结果为84-94，运算结果为-10
./captcha_verify/835-763减8.png的识别结果为763-8，运算结果为755
./captcha_verify/836-2除以39.png的识别结果为2/39，运算结果为0.05128205128205128
./captcha_verify/837-605除以966.png的识别结果为605/966，运算结果为0.6262939958592133
./captcha_verify/838-908减24.png的识别结果为908-24，运算结果为884
./captcha_verify/839-17除以10.png的识别结果为17/10，运算结果为1.7
./captcha_verify/84-7除以97.png的识别结果为7/97，运算结果为0.07216494845360824
./captcha_verify/840-7除以24.png的识别结果为7/24，运算结果为0.2916666666666667
./captcha_verify/841-23除以5.png的识别结果为23/5，运算结果为4.6
./captcha_verify/842-506加76.png的识别结果为506+76，运算结果为582
./captcha_verify/843-280减43.png的识别结果为280-43，运算结果为237
./captcha_verify/844-19加6.png的识别结果为19+6，运算结果为25
./captcha_verify/845-2减131.png的识别结果为2-131，运算结果为-129
./captcha_verify/846-96乘10.png的识别结果为96*10，运算结果为960
./captcha_verify/847-7减274.png的识别结果为7-274，运算结果为-267
./captcha_verify/848-36除以24.png的识别结果为36/24，运算结果为1.5
./captcha_verify/849-603除以8.png的识别结果为603/8，运算结果为75.375
./captcha_verify/85-7减35.png的识别结果为7-35，运算结果为-28
./captcha_verify/850-41除以9.png图片处理失败
./captcha_verify/851-9除以376.png的识别结果为9/376，运算结果为0.023936170212765957
./captcha_verify/852-16加215.png的识别结果为16+215，运算结果为231
./captcha_verify/853-6加68.png的识别结果为6+68，运算结果为74
./captcha_verify/854-7减92.png的识别结果为7-92，运算结果为-85
./captcha_verify/855-90除以3.png的识别结果为9/13，运算结果为0.6923076923076923
./captcha_verify/856-92减24.png的识别结果为92-24，运算结果为68
./captcha_verify/857-421加83.png的识别结果为421+83，运算结果为504
./captcha_verify/858-8除以37.png图片处理失败
./captcha_verify/859-413乘898.png的识别结果为413*898，运算结果为370874
./captcha_verify/86-5除以391.png的识别结果为5/391，运算结果为0.01278772378516624
./captcha_verify/860-75除以2.png的识别结果为75/2，运算结果为37.5
./captcha_verify/861-675加406.png的识别结果为675+406，运算结果为1081
./captcha_verify/862-542乘284.png图片处理失败
./captcha_verify/863-802乘649.png的识别结果为802*649，运算结果为520498
./captcha_verify/864-8乘4.png的识别结果为8*4，运算结果为32
./captcha_verify/865-9除以4.png的识别结果为9/4，运算结果为2.25
./captcha_verify/866-6加36.png的识别结果为6+36，运算结果为42
./captcha_verify/867-51乘2.png的识别结果为51*2，运算结果为102
./captcha_verify/868-409加2.png的识别结果为409+2，运算结果为411
./captcha_verify/869-45加2.png的识别结果为45+2，运算结果为47
./captcha_verify/87-8减82.png的识别结果为8-82，运算结果为-74
./captcha_verify/870-97乘541.png图片处理失败
./captcha_verify/871-6加68.png的识别结果为6+68，运算结果为74
./captcha_verify/872-412减1.png的识别结果为412-1，运算结果为411
./captcha_verify/873-0减696.png的识别结果为0-696，运算结果为-696
./captcha_verify/874-6乘648.png的识别结果为6*648，运算结果为3888
./captcha_verify/875-7乘2.png的识别结果为7*2，运算结果为14
./captcha_verify/876-2减48.png的识别结果为2-48，运算结果为-46
./captcha_verify/877-8加239.png的识别结果为8+239，运算结果为247
./captcha_verify/878-381加7.png的识别结果为381+7，运算结果为388
./captcha_verify/879-23加280.png的识别结果为23+280，运算结果为303
./captcha_verify/88-710除以750.png的识别结果为710/750，运算结果为0.9466666666666667
./captcha_verify/880-928乘4.png的识别结果为928*4，运算结果为3712
./captcha_verify/881-90加97.png的识别结果为90+97，运算结果为187
./captcha_verify/882-46加26.png的识别结果为46+26，运算结果为72
./captcha_verify/883-259除以99.png的识别结果为259/99，运算结果为2.6161616161616164
./captcha_verify/884-32减3.png的识别结果为32-3，运算结果为29
./captcha_verify/885-95乘484.png的识别结果为95*484，运算结果为45980
./captcha_verify/886-326除以7.png的识别结果为326/7，运算结果为46.57142857142857
./captcha_verify/887-91加30.png的识别结果为91+30，运算结果为121
./captcha_verify/888-54加72.png的识别结果为54+72，运算结果为126
./captcha_verify/889-92除以10.png的识别结果为92/10，运算结果为9.2
./captcha_verify/89-95乘2.png图片处理失败
./captcha_verify/890-439乘25.png的识别结果为439*25，运算结果为10975
./captcha_verify/891-53乘3.png的识别结果为53*3，运算结果为159
./captcha_verify/892-908除以9.png的识别结果为908/9，运算结果为100.88888888888889
./captcha_verify/893-837减41.png的识别结果为837-41，运算结果为796
./captcha_verify/894-65加296.png的识别结果为65+296，运算结果为361
./captcha_verify/895-91减9.png的识别结果为91-9，运算结果为82
./captcha_verify/896-4减11.png的识别结果为4-11，运算结果为-7
./captcha_verify/897-864加6.png的识别结果为864+6，运算结果为870
./captcha_verify/898-4乘393.png的识别结果为4*393，运算结果为1572
./captcha_verify/899-561减498.png的识别结果为561-498，运算结果为63
./captcha_verify/9-460加26.png的识别结果为460+26，运算结果为486
./captcha_verify/90-19除以81.png的识别结果为19/81，运算结果为0.2345679012345679
./captcha_verify/900-746减491.png的识别结果为746-491，运算结果为255
./captcha_verify/901-0加7.png的识别结果为0+7，运算结果为7
./captcha_verify/902-5乘739.png的识别结果为5*739，运算结果为3695
./captcha_verify/903-693乘630.png的识别结果为693*630，运算结果为436590
./captcha_verify/904-67乘209.png的识别结果为67*209，运算结果为14003
./captcha_verify/905-3加288.png的识别结果为3+288，运算结果为291
./captcha_verify/906-28乘763.png的识别结果为28*763，运算结果为21364
./captcha_verify/907-23减25.png的识别结果为23-25，运算结果为-2
./captcha_verify/908-47加6.png的识别结果为47+6，运算结果为53
./captcha_verify/909-30加1.png的识别结果为30+1，运算结果为31
./captcha_verify/91-82乘2.png的识别结果为82*2，运算结果为164
./captcha_verify/910-3除以6.png的识别结果为3/6，运算结果为0.5
./captcha_verify/911-879乘71.png的识别结果为879*71，运算结果为62409
./captcha_verify/912-176减38.png的识别结果为176-38，运算结果为138
./captcha_verify/913-896减672.png的识别结果为896-672，运算结果为224
./captcha_verify/914-365乘72.png的识别结果为365*72，运算结果为26280
./captcha_verify/915-29除以96.png图片处理失败
./captcha_verify/916-2除以6.png的识别结果为2/6，运算结果为0.3333333333333333
./captcha_verify/917-97乘7.png的识别结果为97*7，运算结果为679
./captcha_verify/918-4除以3.png的识别结果为4/3，运算结果为1.3333333333333333
./captcha_verify/919-68除以822.png的识别结果为68/822，运算结果为0.0827250608272506
./captcha_verify/92-746加9.png的识别结果为746+9，运算结果为755
./captcha_verify/920-704乘802.png的识别结果为704*802，运算结果为564608
./captcha_verify/921-6减3.png的识别结果为6-3，运算结果为3
./captcha_verify/922-618加86.png的识别结果为618+86，运算结果为704
./captcha_verify/923-60减10.png的识别结果为60-10，运算结果为50
./captcha_verify/924-9除以599.png的识别结果为9/599，运算结果为0.015025041736227046
./captcha_verify/925-21加1.png的识别结果为21+1，运算结果为22
./captcha_verify/926-8乘21.png的识别结果为8*21，运算结果为168
./captcha_verify/927-37减5.png的识别结果为37-5，运算结果为32
./captcha_verify/928-325减585.png的识别结果为325-585，运算结果为-260
./captcha_verify/929-940加9.png的识别结果为940+9，运算结果为949
./captcha_verify/93-54加28.png图片处理失败
./captcha_verify/930-91减83.png的识别结果为91-83，运算结果为8
./captcha_verify/931-0除以1.png的识别结果为0/1，运算结果为0.0
./captcha_verify/932-945除以66.png的识别结果为945/66，运算结果为14.318181818181818
./captcha_verify/933-53加725.png的识别结果为53+725，运算结果为778
./captcha_verify/934-75除以3.png的识别结果为75/3，运算结果为25.0
./captcha_verify/935-1除以4.png的识别结果为1/4，运算结果为0.25
./captcha_verify/936-65加91.png的识别结果为65+91，运算结果为156
./captcha_verify/937-138加4.png的识别结果为138+4，运算结果为142
./captcha_verify/938-586加175.png的识别结果为586+175，运算结果为761
./captcha_verify/939-2加402.png的识别结果为2+402，运算结果为404
./captcha_verify/94-97乘5.png的识别结果为97*5，运算结果为485
./captcha_verify/940-0除以824.png的识别结果为0/824，运算结果为0.0
./captcha_verify/941-7减35.png的识别结果为7-35，运算结果为-28
./captcha_verify/942-7减60.png的识别结果为7-60，运算结果为-53
./captcha_verify/943-7减6.png的识别结果为7-6，运算结果为1
./captcha_verify/944-37减390.png的识别结果为37-390，运算结果为-353
./captcha_verify/945-3乘1.png的识别结果为3*1，运算结果为3
./captcha_verify/946-5除以752.png的识别结果为5/752，运算结果为0.006648936170212766
./captcha_verify/947-51除以8.png的识别结果为51/8，运算结果为6.375
./captcha_verify/948-95乘21.png的识别结果为95*21，运算结果为1995
./captcha_verify/949-9减8.png的识别结果为9-8，运算结果为1
./captcha_verify/95-627加7.png的识别结果为627+7，运算结果为634
./captcha_verify/950-329乘99.png的识别结果为329*99，运算结果为32571
./captcha_verify/951-91除以5.png的识别结果为91/5，运算结果为18.2
./captcha_verify/952-8加469.png的识别结果为8+469，运算结果为477
./captcha_verify/953-5除以14.png的识别结果为5/14，运算结果为0.35714285714285715
./captcha_verify/954-480加7.png的识别结果为480+7，运算结果为487
./captcha_verify/955-9乘7.png的识别结果为9*7，运算结果为63
./captcha_verify/956-579加76.png的识别结果为579+76，运算结果为655
./captcha_verify/957-6减9.png的识别结果为6-9，运算结果为-3
./captcha_verify/958-271除以10.png的识别结果为271/10，运算结果为27.1
./captcha_verify/959-864减8.png的识别结果为864-8，运算结果为856
./captcha_verify/96-87乘31.png的识别结果为87*31，运算结果为2697
./captcha_verify/960-802加397.png的识别结果为802+397，运算结果为1199
./captcha_verify/961-7加32.png的识别结果为7+32，运算结果为39
./captcha_verify/962-63乘10.png图片处理失败
./captcha_verify/963-2乘9.png的识别结果为2*9，运算结果为18
./captcha_verify/964-912除以59.png的识别结果为912/59，运算结果为15.457627118644067
./captcha_verify/965-1减88.png的识别结果为1-88，运算结果为-87
./captcha_verify/966-4乘2.png的识别结果为4*2，运算结果为8
./captcha_verify/967-8乘71.png的识别结果为8*71，运算结果为568
./captcha_verify/968-96除以592.png的识别结果为96/592，运算结果为0.16216216216216217
./captcha_verify/969-725除以3.png的识别结果为725/3，运算结果为241.66666666666666
./captcha_verify/97-24加36.png图片处理失败
./captcha_verify/970-9加57.png的识别结果为9+57，运算结果为66
./captcha_verify/971-32加7.png的识别结果为32+7，运算结果为39
./captcha_verify/972-86除以48.png的识别结果为86/48，运算结果为1.7916666666666667
./captcha_verify/973-5乘5.png的识别结果为5*5，运算结果为25
./captcha_verify/974-6加4.png的识别结果为6+4，运算结果为10
./captcha_verify/975-43乘41.png的识别结果为43*41，运算结果为1763
./captcha_verify/976-8减453.png的识别结果为8-453，运算结果为-445
./captcha_verify/977-564除以6.png的识别结果为564/6，运算结果为94.0
./captcha_verify/978-47减72.png的识别结果为47-72，运算结果为-25
./captcha_verify/979-19减282.png的识别结果为19-282，运算结果为-263
./captcha_verify/98-7乘95.png的识别结果为7*95，运算结果为665
./captcha_verify/980-50除以5.png的识别结果为50/5，运算结果为10.0
./captcha_verify/981-10减537.png的识别结果为10-537，运算结果为-527
./captcha_verify/982-8减37.png的识别结果为8-37，运算结果为-29
./captcha_verify/983-5减170.png的识别结果为5-170，运算结果为-165
./captcha_verify/984-68乘30.png的识别结果为68*30，运算结果为2040
./captcha_verify/985-903乘146.png的识别结果为903*146，运算结果为131838
./captcha_verify/986-1加6.png的识别结果为1+6，运算结果为7
./captcha_verify/987-0乘563.png图片处理失败
./captcha_verify/988-17减638.png的识别结果为17-638，运算结果为-621
./captcha_verify/989-93除以125.png的识别结果为93/125，运算结果为0.744
./captcha_verify/99-4乘74.png的识别结果为4*74，运算结果为296
./captcha_verify/990-16乘19.png的识别结果为16*19，运算结果为304
./captcha_verify/991-94除以1.png的识别结果为94/1，运算结果为94.0
./captcha_verify/992-0减97.png的识别结果为0-97，运算结果为-97
./captcha_verify/993-7加74.png的识别结果为7+74，运算结果为81
./captcha_verify/994-6乘96.png的识别结果为6*96，运算结果为576
./captcha_verify/995-326乘269.png的识别结果为326*269，运算结果为87694
./captcha_verify/996-409除以29.png的识别结果为409/29，运算结果为14.10344827586207
./captcha_verify/997-9加296.png的识别结果为9+296，运算结果为305
./captcha_verify/998-7除以1.png的识别结果为7/1，运算结果为7.0
./captcha_verify/999-453除以3.png的识别结果为453/3，运算结果为151.0
0.9968051118210862

predict.py完整代码如下所示：

# predict.py
import os
import pickle
import cv2 as cv
import numpy as np
from process import adjust_img, split_img
from captcha import generate_captcha, Chinese2operator


def load_model(mode_path):
    """加载模型"""
    with open(mode_path, "rb") as f:
        model = pickle.load(f)
    return model


def predict(model, file_path):
    seed = "0123456789+-*/"   # 字符池

    img = cv.imread(file_path)
    img = adjust_img(img)

    # 预测结果和真实结果
    predict_result = ""
    real_captcha = Chinese2operator(file_path.split("-")[-1].replace(".png", ""))

    # 如果图像处理成功，则返回单个数字图像的预测结果和真实结果
    # 如果没成功，则返回0000和真实结果
    is_ok, roi_list = split_img(img, real_captcha)
    if is_ok:
        for i, roi in enumerate(roi_list):
            predict_result += seed[(model.predict(roi.reshape(1, -1))[0])]
        print(f"{file_path}的识别结果为{predict_result}，运算结果为{eval(predict_result)}")
        return predict_result, real_captcha
    else:
        print(f"{file_path}图片处理失败")
        return False, None


def get_accuracy(model, captcha_dir):
    """获取验证准确度"""
    all_predict_result = []
    all_real_result = []

    for filename in sorted(os.listdir(captcha_dir)):
        if filename != ".DS_Store":  # Mac电脑上的一种文件，排除掉
            predict_result, real_result = predict(model, f"{captcha_dir}/{filename}")
            if predict_result:
                all_predict_result.append(predict_result)
                all_real_result.append(real_result)

    accuracy = (np.array(all_predict_result) == np.array(all_real_result)).sum() / len(all_predict_result)
    return accuracy


def main():
    captcha_dir = "./captcha_verify"
    generate_captcha(1000, captcha_dir)
    model = load_model("./model.pkl")
    accuracy = get_accuracy(model, captcha_dir)
    print(accuracy)


if __name__ == "__main__":
    main()