关于滑块验证码的问题

一、超级鹰

是一个智能图片验证码识别、图片分类平台。

工具网址：https://www.chaojiying.com/

步骤：

1、注册账号密码进行登录；

2、进入登录界面之后，点击软件 ID，生成一个软件 ID；

3、填入对应的软件名称和软件说明，软件 KEY 不用改，最后点击提交按钮；

4、点击”开发文档“选项，选择“超级鹰图像识别 Python 语言 Demo 下载”选项，将对应代码的压缩包下载下来，解压；

5、解压后的文件里，找到.py文件，通过 pycharm 打开后，按提示修改以下代码。

if __name__ == '__main__':
    #用户中心>>软件ID 生成一个替换 96001
    chaojiying = Chaojiying_Client('超级鹰用户名', '超级鹰用户名的密码', '96001')
    #本地图片文件路径 来替换 a.jpg 有时WIN系统须要//
    im = open('a.jpg', 'rb').read()
    #1902 验证码类型  官方网站>>价格体系 3.4+版 print 后要加()
    print(chaojiying.PostPic(im, 1902))
    #print chaojiying.PostPic(base64_str, 1902)  #此处为传入 base64代码

二、图片验证模拟登录

目标网站：https://www.bilibili.com/

需求：模拟登录

1、页面分析

采用 selenium 技术进行模拟登录

1.1、模拟用户正常登录流程

• 在网站首页点击登录按钮；
• 弹出框输入账号和密码，点击登录按钮；
• 出现验证码图片识别。

1.2、识别图片里面的文字

• 获取要识别的文字（通过 selenium 的截图功能，先截全屏，然后将验证码图片抠出来）；
• 使用超级鹰识别验证码图片文字，获取文字的坐标；
• 根据文字坐标进行点击；
• 点击完成，最后点击确认按钮。

2、代码实现

import time # 导入 time 模块，用于时间相关操作
from PIL import Image # 导入 Image 模块，用于图像处理
from selenium import webdriver # 导入 webdriver 模块，用于自动化测试和控制浏览器
from selenium.webdriver import ActionChains # 导入 ActionChains 类，用于模拟用户操作
from selenium.webdriver.common.by import By # 导入 By 类，用于定位元素
from selenium.webdriver.support.wait import WebDriverWait # 导入 WebDriverWait 类，用于等待元素加载
from selenium.webdriver.support import expected_conditions as EC # 导入 EC 模块，用于预期条件判断
from chaojiying_Python.chaojiying import Chaojiying_Client # 引入超级鹰验证码识别 API 客户端

class Bili_login(object):
    # 初始法方法，用户名跟密码
    def __init__(self, username, password):
        # 加载驱动
        self.driver = webdriver.Chrome()
        # 窗口最大化
        self.driver.maximize_window()
        # 目标 url
        self.url = 'https://www.bilibili.com/'
        # 用户名
        self.username = username
        # 密码
        self.password = password
        # 显示等待，判断驱动是否加载出来
        self.wait = WebDriverWait(self.driver, 100)

    # 加载得到验证码图片
    def get_img(self):
        # 加载网站
        self.driver.get(self.url)
        # 等待2秒
        time.sleep(2)
        # 点击登录
        self.driver.find_element(By.CLASS_NAME, 'header-login-entry').click()
        # 显示等待，判断账号与密码输入框是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'login-pwd-wp')) # 注意方法里面要填元组
        )
        # 输入账号
        self.driver.find_element(By.XPATH, '//form[@class="tab__form"]/div[1]/input').send_keys(self.username)
        # 等待0.5秒
        time.sleep(0.5)
        # 输入密码
        self.driver.find_element(By.XPATH, '//form[@class="tab__form"]/div[3]/input').send_keys(self.username)
        # 点击登录
        self.driver.find_element(By.CLASS_NAME, 'btn_primary ').click()
        # 判断验证码元素是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'geetest_item_img'))
        )
        # 保存验证码图片
        div_img = self.save_img()
        # 返回验证码图片
        return div_img

    # 下载验证码图片到本地
    def save_img(self):
        # 等待2秒
        time.sleep(2)
        # 截全屏图片
        self.driver.save_screenshot('images/back_img.png')
        # 获取验证码图片的元素
        div_img = self.driver.find_element(By.CLASS_NAME, 'geetest_panel_next')
        # 获取左上角的坐标，返回 x,y 的坐标
        location = div_img.location
        # 获取宽度和高度
        size = div_img.size
        # 获取左上角的坐标
        x1, y1 = int(location['x']), int(location['y'])
        # 获取右下角的坐标
        x2, y2 = x1 + size['width'], y1 + size['height']
        # 加载背景图
        back_img = Image.open('images/back_img.png')
        # 截图，截图建议电脑缩放比例为100%
        img = back_img.crop((x1, y1, x2, y2))
        # 保存图片
        img.save('images/验证码图片.png')
        # 返回验证码图片的元素
        return div_img

    # 点击文字做验证
    def click_font(self, loc_dic, div_img):
        # 循环依次点击
        for x, y in loc_dic.items():
            # 鼠标行为链
            action = ActionChains(self.driver)
            # 鼠标移动点击
            action.move_to_element_with_offset(div_img, int(x), int(y)).click().perform()
        # 等待1秒
        time.sleep(1)
        # 点击确定
        self.driver.find_element(By.CLASS_NAME, 'geetest_commit_tip').click()

    # 主逻辑处理
    def main(self):
        # 加载得到验证码图片
        div_img = self.get_img()
        # 用超级鹰识别位置
        chaojiying = Chaojiying_Client('替换超级鹰用户名', '替换超级鹰用户名的密码', '949117')
        # 本地图片文件路径
        im = open('images/验证码图片.png', 'rb').read()
        # 验证码类型
        log_list = chaojiying.PostPic(im, 9004)['pic_str'].split('|')
        # 处理坐标数据
        loc_dic = {i.split(',')[0]: i.split(',')[1] for i in log_list}
        # 打印位置坐标
        # print(loc_dic)
        # 点击图片内文字
        self.click_font(loc_dic, div_img)

# 主程序
if __name__ == '__main__':
    # 创建了一个对象
    b = Bili_login('123456', '123456')
    # 调用 main 方法
    b.main()

三、滑块模拟登录

目标网站：https://www.geetest.com/demo/slide-float.html

需求：模拟登录

1、页面分析

点击“点击按钮进行验证"，会出现滑块。

滑块验证一般使用 selenium 实现，需要先确定滑动的距离。

获取缺口位置（三种方法）

• 通过对比像素获取缺口位置
• 通过 openCV 的方式，得到缺口位置
• 百度智能云（机器学习）识别缺口位置

使用 selenium 进行滑动。

2、代码实现（通过对比像素获取缺口位置）

将图片保存下来，通过像素识别，需要获取两张图片。一张背景图片（有缺口），一张完整图片。对比像素，拿到缺口位置的坐标，使用 selenium 进行滑动。

import random  # 导入 random 模块，用于生成随机数
import time  # 导入 time 模块，用于时间相关操作
import pyautogui  # 导入 pyautogui 模块，用于控制鼠标和键盘
from PIL import Image  # 导入 Image 模块，用于图像处理
from selenium.webdriver.support.wait import WebDriverWait  # 导入 WebDriverWait 类，用于等待元素加载
from selenium import webdriver  # 导入 webdriver 模块，用于自动化测试和控制浏览器
from selenium.webdriver.support import expected_conditions as EC  # 导入 EC 模块，用于预期条件判断
from selenium.webdriver.common.by import By  # 导入 By 类，用于定位元素

class FloatSlide(object):
    # 初始化方法
    def __init__(self):
        # 确定 url
        self.url = 'https://www.geetest.com/demo/slide-float.html'
        # 加载驱动
        self.driver = webdriver.Chrome()
        # 最大化窗口
        self.driver.maximize_window()
        # 显示等待
        self.wait = WebDriverWait(self.driver, 100)
        # 缺口图片保存位置
        self.gap_img = 'images/gap.png'
        # 完整图片保存位置
        self.intact_img = 'images/intact.png'

    # 加载图片并截取图片
    def load_img(self):
        # 加载网站
        self.driver.get(self.url)
        # 等待2秒
        time.sleep(2)
        # 点击按钮
        self.driver.find_element(By.CLASS_NAME, 'geetest_radar_tip').click()
        # 用显示判断，图片是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.XPATH, '//div[@class="geetest_slicebg geetest_absolute"]'))
        )
        # 修改样式，获取缺口图片
        self.driver.execute_script('document.querySelectorAll("canvas")[1].style="opacity: 1; display: none;"')
        # 找到验证码图片的标签元素
        div_img = self.driver.find_element(By.CLASS_NAME, 'geetest_window')
        # 等待1秒
        time.sleep(1)
        # 缺口图片的保存位置
        div_img.screenshot(self.gap_img)
        # 修改样式，获取完整图片
        self.driver.execute_script('document.querySelectorAll("canvas")[2].style=""')
        # 完整图片的保存位置
        div_img.screenshot(self.intact_img)
        # 恢复样式
        self.driver.execute_script('document.querySelectorAll("canvas")[1].style="opacity: 1; display: block;"')

    # 对比验证图片，获取缺口位置
    def get_gap(self):
        # 加载缺口图片
        gap_img = Image.open(self.gap_img)
        # 加载完整图片
        intact_img = Image.open(self.intact_img)
        # 从第一个位置开始做对比
        left = 0
        # 嵌套循环做对比
        for x in range(0, gap_img.size[0]):
            for y in range(0, gap_img.size[1]):
                # 判断像素
                if not self.is_pixel_equal(gap_img, intact_img, x, y):
                    # 相同赋值给 left
                    left = x
                    # 不相同，返回 x 坐标
                    return left

    # 判断像素
    def is_pixel_equal(self, gap_img, intact_img, x, y):
        # 加载缺口图片位置
        pixel1 = gap_img.load()[x, y]
        # 加载完整图片位置
        pixel2 = intact_img.load()[x, y]
        # 打印图片位置
        # print(pixel1, pixel2)
        # 阈值
        threshold = 60
        # 对比 RGB
        if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(pixel1[2] - pixel2[2]) < threshold:
            # 在阈值内相似返回 True
            return True
        # 不在阈值内不相似返回 False，缺口找到
        return False

    # 滑动滑块
    def move_slide(self, offset_x, offset_y, left):
        # pip install pyautogui 导入 pyautogui 模块，用于控制鼠标和键盘
        # 将鼠标移动到指定位置 (offset_x, offset_y)
        pyautogui.moveTo(offset_x, offset_y, duration=0.1 + random.uniform(0, 0.1 + random.randint(1, 100) / 100))
        # 按下鼠标，准备开始滑动
        pyautogui.mouseDown()
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(9, 19)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(15, 25) / 20), offset_y, duration=0.28)
        # 在当前 offset_y 的基础上减少一个随机值
        offset_y += random.randint(-9, 0)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(17, 23) / 20), offset_y,duration=random.randint(20, 31) / 100)
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(0, 8)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(19, 21) / 20), offset_y,duration=random.randint(20, 40) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-3, 3)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-3, 3), offset_y,duration=0.5 + random.randint(-10, 10) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-2, 2)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-2, 2), offset_y, duration=0.5 + random.randint(-3, 3) / 100)
        # 松开鼠标左键，结束滑动操作
        pyautogui.mouseUp()
        # 等待3秒
        time.sleep(3)

    # 主函数
    def main(self):
        # 加载图片并截取图片
        self.load_img()
        # 对比验证图片，获取缺口位置
        left = self.get_gap()
        # 误差值
        left -= 6
        # 根据位置滑动滑块(测量一下浏览器左上角到滑块按钮的距离)
        x = 1260
        y = 490
        # 滑动滑块
        self.move_slide(x, y, left)

# 主程序
if __name__ == '__main__':
    # 创建了一个对象
    f = FloatSlide()
    # 调用 main 方法
    f.main()

四、openCV

1、简介

OpenCV（Open Source Computer Vision）是一个开源的计算机视觉库，它提供了丰富的图像和视频处理函数，可用于开发计算机视觉相关的应用程序。

2、代码

识别缺口位置，获取缺口距离。

# pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple
import cv2

def identify_gap(bg_image, tp_image, out="images/new_image.png"):
    """
    通过cv2计算缺口位置
    :param bg_image: 有缺口的背景图片文件
    :param tp_image: 缺口小图文件图片文件
    :param out: 绘制缺口边框之后的图片
    :return: 返回缺口位置
    """
    # 读取背景图片和缺口图片
    bg_img = cv2.imread(bg_image)  # 背景图片
    tp_img = cv2.imread(tp_image)  # 缺口图片
    # 识别图片边缘
    # 因为验证码图片里面的目标缺口通常是有比较明显的边缘 所以可以借助边缘检测算法结合调整阈值来识别缺口
    # 目前应用比较广泛的边缘检测算法是Canny John F.Canny在1986年所开发的一个多级边缘检测算法 效果挺好的
    bg_edge = cv2.Canny(bg_img, 100, 200)
    tp_edge = cv2.Canny(tp_img, 100, 200)
    print(bg_edge, tp_edge)
    # 转换图片格式
    # 得到了图片边缘的灰度图，进一步将其图片格式转为RGB格式
    bg_pic = cv2.cvtColor(bg_edge, cv2.COLOR_GRAY2RGB)
    tp_pic = cv2.cvtColor(tp_edge, cv2.COLOR_GRAY2RGB)

    # 缺口匹配
    # 一幅图像中找与另一幅图像最匹配(相似)部分 算法：cv2.TM_CCOEFF_NORMED
    # 在背景图片中搜索对应的缺口
    res = cv2.matchTemplate(bg_pic, tp_pic, cv2.TM_CCOEFF_NORMED)
    # res为每个位置的匹配结果，代表了匹配的概率，选出其中「概率最高」的点，即为缺口匹配的位置
    # 从中获取min_val，max_val，min_loc，max_loc分别为匹配的最小值、匹配的最大值、最小值的位置、最大值的位置
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)  # 寻找最优匹配

    # 绘制方框
    th, tw = tp_pic.shape[:2]
    tl = max_loc  # 左上角点的坐标
    br = (tl[0] + tw, tl[1] + th)  # 右下角点的坐标
    cv2.rectangle(bg_img, tl, br, (0, 0, 255), 2)  # 绘制矩形
    cv2.imwrite(out, bg_img)  # 保存在本地

    # 返回缺口的X坐标
    return tl[0]

# 传入两张图片，返回缺口位置
left = identify_gap('images/jindong_bg.png', 'images/jingdong_gap.png')

3、案例

需求：用 selenium 进行模拟登录

目标网站：https://passport.jd.com/new/login.aspx

页面分析

• 切换密码登录模式
• 输入账号和密码
• 点击登录按钮
• 加载完滑块之后，获取滑块验证码图片
• 识别缺口位置，获取距离，进行滑动

代码实现

1、搭建框架

import random # 导入 random 模块，用于生成随机数
import time # 导入 time 模块，用于添加时间延迟
import cv2 # 导入 OpenCV 模块，用于图像处理
import pyautogui # 导入 pyautogui 模块，用于模拟鼠标和键盘操作
from selenium.webdriver.support.wait import WebDriverWait # 导入 WebDriverWait 类，用于等待条件
from selenium import webdriver # 导入 webdriver 模块，用于控制浏览器
from selenium.webdriver.support import expected_conditions as EC # 导入 expected_conditions 模块，用于指定预期条件
from selenium.webdriver.common.by import By # 导入 By 模块，用于指定元素定位方式
from PIL import Image # 导入 Image 模块，用于图像处理
import urllib.request # 导入 urllib.request 模块，用于进行网络请求

class JinDong_Logic(object):
    # 初始化操作
    def __init__(self, username, password):
        pass

    # 获取缺口图片
    def login(self):
        pass

    # 计算缺口位置
    def identify_gap(self, bg_image, tp_image, out="images/new_image.png"):
        pass

    # 滑动函数
    def move_slide(self, offset_x, offset_y, left):
        pass

# 主程序
if __name__ == '__main__':
    # 创建对象
    l = JinDong_Logic('123', 'abcd')
    # 调用 login 方法
    l.login()

2、初始化操作

# 初始化操作
    def __init__(self, username, password):
        # 确定 url
        self.url = 'https://passport.jd.com/new/login.aspx'
        # 账号
        self.username = username
        # 密码
        self.password = password
        # 加载驱动
        self.driver = webdriver.Chrome()
        # 窗口最大化
        self.driver.maximize_window()
        # 显示等待
        self.wait = WebDriverWait(self.driver, 100)
        # 设置图片保存位置
        # 有缺口的背景图片
        self.bg_img = 'images/bg_img.png'
        # 缺口小图片
        self.gap_img = 'images/gap_img.png'

3、获取缺口图片

# 获取缺口图片
    def login(self):
        # 加载 url
        self.driver.get(self.url)
        # 等待1秒
        time.sleep(1)
        # 切换登录方式
        self.driver.find_element(By.CLASS_NAME, 'login-tab-r').click()
        # 输入账号
        self.driver.find_element(By.ID, 'loginname').send_keys(self.username)
        # 输入密码
        self.driver.find_element(By.ID, 'nloginpwd').send_keys(self.password)
        # 等待0.5秒
        time.sleep(0.5)
        # 点击登录按钮
        self.driver.find_element(By.ID, 'loginsubmit').click()
        # 显示等待判断图片是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'JDJRV-slide '))
        )
        # 获取背景图片（向图片链接发请求，获取图片)
        bg_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-bigimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(bg_img_url, self.bg_img)
        # 获取缺口图片
        gap_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-smallimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(gap_img_url, self.gap_img)
        # 修改背景图片的尺寸
        im = Image.open(self.bg_img)
        # 重新设置图片尺寸
        image = im.resize((278, 108))
        # 保存图片
        image.save('images/1.png')
        # 修改缺口图片的尺寸
        im1 = Image.open(self.gap_img)
        # 重新设置图片尺寸
        image1 = im1.resize((39, 39))
        # 保存图片
        image1.save('images/2.png')
        # 获取两张图片，计算缺口位置，识别距离
        left = self.identify_gap('images/1.png', 'images/2.png')
        # 根据位置滑动滑块(测量一下浏览器左上角到滑块按钮的距离)
        x, y = 1485, 485
        # 滑动
        self.move_slide(x, y, left)

4、计算缺口位置

# 计算缺口位置
    def identify_gap(self, bg_image, tp_image, out="images/new_image.png"):
        """
            通过cv2计算缺口位置
            :param bg_image: 有缺口的背景图片文件
            :param tp_image: 缺口小图文件图片文件
            :param out: 绘制缺口边框之后的图片
            :return: 返回缺口位置
            """
        # 读取背景图片和缺口图片
        bg_img = cv2.imread(bg_image)  # 背景图片
        tp_img = cv2.imread(tp_image)  # 缺口图片
        # 识别图片边缘
        # 因为验证码图片里面的目标缺口通常是有比较明显的边缘 所以可以借助边缘检测算法结合调整阈值来识别缺口
        # 目前应用比较广泛的边缘检测算法是Canny John F.Canny在1986年所开发的一个多级边缘检测算法 效果挺好的
        bg_edge = cv2.Canny(bg_img, 100, 200)
        tp_edge = cv2.Canny(tp_img, 100, 200)
        print(bg_edge, tp_edge)
        # 转换图片格式
        # 得到了图片边缘的灰度图，进一步将其图片格式转为RGB格式
        bg_pic = cv2.cvtColor(bg_edge, cv2.COLOR_GRAY2RGB)
        tp_pic = cv2.cvtColor(tp_edge, cv2.COLOR_GRAY2RGB)

        # 缺口匹配
        # 一幅图像中找与另一幅图像最匹配(相似)部分 算法：cv2.TM_CCOEFF_NORMED
        # 在背景图片中搜索对应的缺口
        res = cv2.matchTemplate(bg_pic, tp_pic, cv2.TM_CCOEFF_NORMED)
        # res为每个位置的匹配结果，代表了匹配的概率，选出其中「概率最高」的点，即为缺口匹配的位置
        # 从中获取min_val，max_val，min_loc，max_loc分别为匹配的最小值、匹配的最大值、最小值的位置、最大值的位置
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)  # 寻找最优匹配

        # 绘制方框
        th, tw = tp_pic.shape[:2]
        tl = max_loc  # 左上角点的坐标
        br = (tl[0] + tw, tl[1] + th)  # 右下角点的坐标
        cv2.rectangle(bg_img, tl, br, (0, 0, 255), 2)  # 绘制矩形
        cv2.imwrite(out, bg_img)  # 保存在本地

        # 返回缺口的X坐标
        return tl[0]

5、滑动函数

# 滑动函数
    def move_slide(self, offset_x, offset_y, left):
        # pip install pyautogui 导入 pyautogui 模块，用于控制鼠标和键盘
        # 将鼠标移动到指定位置 (offset_x, offset_y)
        pyautogui.moveTo(offset_x, offset_y, duration=0.1 + random.uniform(0, 0.1 + random.randint(1, 100) / 100))
        # 按下鼠标，准备开始滑动
        pyautogui.mouseDown()
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(9, 19)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(15, 25) / 20), offset_y, duration=0.28)
        # 在当前 offset_y 的基础上减少一个随机值
        offset_y += random.randint(-9, 0)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(17, 23) / 20), offset_y,
                         duration=random.randint(20, 31) / 100)
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(0, 8)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(19, 21) / 20), offset_y,
                         duration=random.randint(20, 40) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-3, 3)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-3, 3), offset_y,
                         duration=0.5 + random.randint(-10, 10) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-2, 2)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-2, 2), offset_y, duration=0.5 + random.randint(-3, 3) / 100)
        # 松开鼠标左键，结束滑动操作
        pyautogui.mouseUp()
        # 等待3秒
        time.sleep(3)

完整代码

import random # 导入 random 模块，用于生成随机数
import time # 导入 time 模块，用于添加时间延迟
import cv2 # 导入 OpenCV 模块，用于图像处理
import pyautogui # 导入 pyautogui 模块，用于模拟鼠标和键盘操作
from selenium.webdriver.support.wait import WebDriverWait # 导入 WebDriverWait 类，用于等待条件
from selenium import webdriver # 导入 webdriver 模块，用于控制浏览器
from selenium.webdriver.support import expected_conditions as EC # 导入 expected_conditions 模块，用于指定预期条件
from selenium.webdriver.common.by import By # 导入 By 模块，用于指定元素定位方式
from PIL import Image # 导入 Image 模块，用于图像处理
import urllib.request # 导入 urllib.request 模块，用于进行网络请求

class JinDong_Logic(object):
    # 初始化操作
    def __init__(self, username, password):
        # 确定 url
        self.url = 'https://passport.jd.com/new/login.aspx'
        # 账号
        self.username = username
        # 密码
        self.password = password
        # 加载驱动
        self.driver = webdriver.Chrome()
        # 窗口最大化
        self.driver.maximize_window()
        # 显示等待
        self.wait = WebDriverWait(self.driver, 100)
        # 设置图片保存位置
        # 有缺口的背景图片
        self.bg_img = 'images/bg_img.png'
        # 缺口小图片
        self.gap_img = 'images/gap_img.png'

    # 获取缺口图片
    def login(self):
        # 加载 url
        self.driver.get(self.url)
        # 等待1秒
        time.sleep(1)
        # 切换登录方式
        self.driver.find_element(By.CLASS_NAME, 'login-tab-r').click()
        # 输入账号
        self.driver.find_element(By.ID, 'loginname').send_keys(self.username)
        # 输入密码
        self.driver.find_element(By.ID, 'nloginpwd').send_keys(self.password)
        # 等待0.5秒
        time.sleep(0.5)
        # 点击登录按钮
        self.driver.find_element(By.ID, 'loginsubmit').click()
        # 显示等待判断图片是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'JDJRV-slide '))
        )
        # 获取背景图片（向图片链接发请求，获取图片)
        bg_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-bigimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(bg_img_url, self.bg_img)
        # 获取缺口图片
        gap_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-smallimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(gap_img_url, self.gap_img)
        # 修改背景图片的尺寸
        im = Image.open(self.bg_img)
        # 重新设置图片尺寸
        image = im.resize((278, 108))
        # 保存图片
        image.save('images/1.png')
        # 修改缺口图片的尺寸
        im1 = Image.open(self.gap_img)
        # 重新设置图片尺寸
        image1 = im1.resize((39, 39))
        # 保存图片
        image1.save('images/2.png')
        # 获取两张图片，计算缺口位置，识别距离
        left = self.identify_gap('images/1.png', 'images/2.png')
        # 根据位置滑动滑块(测量一下浏览器左上角到滑块按钮的距离)
        x, y = 1485, 485
        # 滑动
        self.move_slide(x, y, left)

    # 计算缺口位置
    def identify_gap(self, bg_image, tp_image, out="images/new_image.png"):
        """
            通过cv2计算缺口位置
            :param bg_image: 有缺口的背景图片文件
            :param tp_image: 缺口小图文件图片文件
            :param out: 绘制缺口边框之后的图片
            :return: 返回缺口位置
            """
        # 读取背景图片和缺口图片
        bg_img = cv2.imread(bg_image)  # 背景图片
        tp_img = cv2.imread(tp_image)  # 缺口图片
        # 识别图片边缘
        # 因为验证码图片里面的目标缺口通常是有比较明显的边缘 所以可以借助边缘检测算法结合调整阈值来识别缺口
        # 目前应用比较广泛的边缘检测算法是Canny John F.Canny在1986年所开发的一个多级边缘检测算法 效果挺好的
        bg_edge = cv2.Canny(bg_img, 100, 200)
        tp_edge = cv2.Canny(tp_img, 100, 200)
        print(bg_edge, tp_edge)
        # 转换图片格式
        # 得到了图片边缘的灰度图，进一步将其图片格式转为RGB格式
        bg_pic = cv2.cvtColor(bg_edge, cv2.COLOR_GRAY2RGB)
        tp_pic = cv2.cvtColor(tp_edge, cv2.COLOR_GRAY2RGB)

        # 缺口匹配
        # 一幅图像中找与另一幅图像最匹配(相似)部分 算法：cv2.TM_CCOEFF_NORMED
        # 在背景图片中搜索对应的缺口
        res = cv2.matchTemplate(bg_pic, tp_pic, cv2.TM_CCOEFF_NORMED)
        # res为每个位置的匹配结果，代表了匹配的概率，选出其中「概率最高」的点，即为缺口匹配的位置
        # 从中获取min_val，max_val，min_loc，max_loc分别为匹配的最小值、匹配的最大值、最小值的位置、最大值的位置
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)  # 寻找最优匹配

        # 绘制方框
        th, tw = tp_pic.shape[:2]
        tl = max_loc  # 左上角点的坐标
        br = (tl[0] + tw, tl[1] + th)  # 右下角点的坐标
        cv2.rectangle(bg_img, tl, br, (0, 0, 255), 2)  # 绘制矩形
        cv2.imwrite(out, bg_img)  # 保存在本地

        # 返回缺口的X坐标
        return tl[0]

    # 滑动函数
    def move_slide(self, offset_x, offset_y, left):
        # pip install pyautogui 导入 pyautogui 模块，用于控制鼠标和键盘
        # 将鼠标移动到指定位置 (offset_x, offset_y)
        pyautogui.moveTo(offset_x, offset_y, duration=0.1 + random.uniform(0, 0.1 + random.randint(1, 100) / 100))
        # 按下鼠标，准备开始滑动
        pyautogui.mouseDown()
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(9, 19)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(15, 25) / 20), offset_y, duration=0.28)
        # 在当前 offset_y 的基础上减少一个随机值
        offset_y += random.randint(-9, 0)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(17, 23) / 20), offset_y,
                         duration=random.randint(20, 31) / 100)
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(0, 8)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(19, 21) / 20), offset_y,
                         duration=random.randint(20, 40) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-3, 3)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-3, 3), offset_y,
                         duration=0.5 + random.randint(-10, 10) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-2, 2)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-2, 2), offset_y, duration=0.5 + random.randint(-3, 3) / 100)
        # 松开鼠标左键，结束滑动操作
        pyautogui.mouseUp()
        # 等待3秒
        time.sleep(3)

# 主程序
if __name__ == '__main__':
    # 创建对象
    l = JinDong_Logic('123', 'abcd')
    # 调用 login 方法
    l.login()

五、selenium 反爬

去除 selenium 标志：

1、进入 chrome 路径

2、在文件路径出输入cmd ，回车，打开终端

3、导入 ChromeOptions 类，用于配置 Chrome 浏览器选项

from selenium.webdriver.chrome.options import Options

4、加入代码

# 创建 Options 对象，用于配置浏览器选项
options = Options()
# 连接浏览器到指定的调试地址
options.add_experimental_option('debuggerAddress', '127.0.0.1:9222')
# 加载驱动
self.driver = webdriver.Chrome(options=options)

5、把谷歌浏览器全部关闭，在终端里启动命令

chrome --remote-debugging-port=9222

6、在 PyCharm 里运行代码

案例

import random # 导入 random 模块，用于生成随机数
import time # 导入 time 模块，用于添加时间延迟
import cv2 # 导入 OpenCV 模块，用于图像处理
import pyautogui # 导入 pyautogui 模块，用于模拟鼠标和键盘操作
from selenium.webdriver.chrome.options import Options # 导入 ChromeOptions 类，用于配置 Chrome 浏览器选项
from selenium.webdriver.support.wait import WebDriverWait # 导入 WebDriverWait 类，用于等待条件
from selenium import webdriver # 导入 webdriver 模块，用于控制浏览器
from selenium.webdriver.support import expected_conditions as EC # 导入 expected_conditions 模块，用于指定预期条件
from selenium.webdriver.common.by import By # 导入 By 模块，用于指定元素定位方式
from PIL import Image # 导入 Image 模块，用于图像处理
import urllib.request # 导入 urllib.request 模块，用于进行网络请求

class JinDong_Logic(object):
    # 初始化操作
    def __init__(self, username, password):
        # 确定 url
        self.url = 'https://passport.jd.com/new/login.aspx'
        # 账号
        self.username = username
        # 密码
        self.password = password
        # 创建 Options 对象，用于配置浏览器选项
        options = Options()
        # 连接浏览器到指定的调试地址
        options.add_experimental_option('debuggerAddress', '127.0.0.1:9222')
        # 加载驱动
        self.driver = webdriver.Chrome(options=options)
        # 窗口最大化
        self.driver.maximize_window()
        # 显示等待
        self.wait = WebDriverWait(self.driver, 100)
        # 设置图片保存位置
        # 有缺口的背景图片
        self.bg_img = 'images/bg_img.png'
        # 缺口小图片
        self.gap_img = 'images/gap_img.png'

    # 获取缺口图片
    def login(self):
        # 加载 url
        self.driver.get(self.url)
        # 等待1秒
        time.sleep(1)
        # 切换登录方式
        self.driver.find_element(By.CLASS_NAME, 'login-tab-r').click()
        # 输入账号
        self.driver.find_element(By.ID, 'loginname').send_keys(self.username)
        # 输入密码
        self.driver.find_element(By.ID, 'nloginpwd').send_keys(self.password)
        # 等待0.5秒
        time.sleep(0.5)
        # 点击登录按钮
        self.driver.find_element(By.ID, 'loginsubmit').click()
        # 显示等待判断图片是否加载出来
        self.wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'JDJRV-slide '))
        )
        # 获取背景图片（向图片链接发请求，获取图片)
        bg_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-bigimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(bg_img_url, self.bg_img)
        # 获取缺口图片
        gap_img_url = self.driver.find_element(By.XPATH, '//div[@class="JDJRV-smallimg"]/img').get_attribute('src')
        # 保存图片
        urllib.request.urlretrieve(gap_img_url, self.gap_img)
        # 修改背景图片的尺寸
        im = Image.open(self.bg_img)
        # 重新设置图片尺寸
        image = im.resize((278, 108))
        # 保存图片
        image.save('images/1.png')
        # 修改缺口图片的尺寸
        im1 = Image.open(self.gap_img)
        # 重新设置图片尺寸
        image1 = im1.resize((39, 39))
        # 保存图片
        image1.save('images/2.png')
        # 获取两张图片，计算缺口位置，识别距离
        left = self.identify_gap('images/1.png', 'images/2.png')
        # 根据位置滑动滑块(测量一下浏览器左上角到滑块按钮的距离)
        x, y = 1485, 455
        # 滑动
        self.move_slide(x, y, left)

    # 计算缺口位置
    def identify_gap(self, bg_image, tp_image, out="images/new_image.png"):
        """
            通过cv2计算缺口位置
            :param bg_image: 有缺口的背景图片文件
            :param tp_image: 缺口小图文件图片文件
            :param out: 绘制缺口边框之后的图片
            :return: 返回缺口位置
            """
        # 读取背景图片和缺口图片
        bg_img = cv2.imread(bg_image)  # 背景图片
        tp_img = cv2.imread(tp_image)  # 缺口图片
        # 识别图片边缘
        # 因为验证码图片里面的目标缺口通常是有比较明显的边缘 所以可以借助边缘检测算法结合调整阈值来识别缺口
        # 目前应用比较广泛的边缘检测算法是Canny John F.Canny在1986年所开发的一个多级边缘检测算法 效果挺好的
        bg_edge = cv2.Canny(bg_img, 100, 200)
        tp_edge = cv2.Canny(tp_img, 100, 200)
        print(bg_edge, tp_edge)
        # 转换图片格式
        # 得到了图片边缘的灰度图，进一步将其图片格式转为RGB格式
        bg_pic = cv2.cvtColor(bg_edge, cv2.COLOR_GRAY2RGB)
        tp_pic = cv2.cvtColor(tp_edge, cv2.COLOR_GRAY2RGB)

        # 缺口匹配
        # 一幅图像中找与另一幅图像最匹配(相似)部分 算法：cv2.TM_CCOEFF_NORMED
        # 在背景图片中搜索对应的缺口
        res = cv2.matchTemplate(bg_pic, tp_pic, cv2.TM_CCOEFF_NORMED)
        # res为每个位置的匹配结果，代表了匹配的概率，选出其中「概率最高」的点，即为缺口匹配的位置
        # 从中获取min_val，max_val，min_loc，max_loc分别为匹配的最小值、匹配的最大值、最小值的位置、最大值的位置
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)  # 寻找最优匹配

        # 绘制方框
        th, tw = tp_pic.shape[:2]
        tl = max_loc  # 左上角点的坐标
        br = (tl[0] + tw, tl[1] + th)  # 右下角点的坐标
        cv2.rectangle(bg_img, tl, br, (0, 0, 255), 2)  # 绘制矩形
        cv2.imwrite(out, bg_img)  # 保存在本地

        # 返回缺口的X坐标
        return tl[0]

    # 滑动函数
    def move_slide(self, offset_x, offset_y, left):
        # pip install pyautogui 导入 pyautogui 模块，用于控制鼠标和键盘
        # 将鼠标移动到指定位置 (offset_x, offset_y)
        pyautogui.moveTo(offset_x, offset_y, duration=0.1 + random.uniform(0, 0.1 + random.randint(1, 100) / 100))
        # 按下鼠标，准备开始滑动
        pyautogui.mouseDown()
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(9, 19)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(15, 25) / 20), offset_y, duration=0.28)
        # 在当前 offset_y 的基础上减少一个随机值
        offset_y += random.randint(-9, 0)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(17, 23) / 20), offset_y,
                         duration=random.randint(20, 31) / 100)
        # 在当前 offset_y 的基础上增加一个随机值
        offset_y += random.randint(0, 8)
        # 将鼠标移动到偏移位置 (offset_x + int(left * 随机值), offset_y)
        pyautogui.moveTo(offset_x + int(left * random.randint(19, 21) / 20), offset_y,
                         duration=random.randint(20, 40) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-3, 3)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-3, 3), offset_y,
                         duration=0.5 + random.randint(-10, 10) / 100)
        # 在当前 offset_y 的基础上增加或减少一个随机值
        offset_y += random.randint(-2, 2)
        # 将鼠标移动到偏移位置 (left + offset_x + 随机值, offset_y)
        pyautogui.moveTo(left + offset_x + random.randint(-2, 2), offset_y, duration=0.5 + random.randint(-3, 3) / 100)
        # 松开鼠标左键，结束滑动操作
        pyautogui.mouseUp()
        # 等待3秒
        time.sleep(3)

# 主程序
if __name__ == '__main__':
    # 创建对象
    l = JinDong_Logic('123', 'abcd')
    # 调用 login 方法
    l.login()

六、百度智能云 —— EasyDL

1、简介

百度智能云的 EasyDL 是一个基于深度学习的图像识别和目标检测平台，它提供了简单易用的接口和工具，使开发者可以轻松构建自己的图像识别模型。

准备该网站有缺口的背景图片，做一个训练集，运用了机器学习知识。将这些训练集导入百度智能云，在此平台标注出每一张图片的缺口位置，根据图片以及标注缺口位置，就能训练出一个模型。

有了该模型，如果传入类似的图片，就可以识别缺口位置，获取缺口的距离。

2、使用步骤

2.1、打开网站 EasyDL-零门槛AI开发平台；

2.2、点击“立即使用”；

2.3、点击“物体检测”；

2.4、点击“数据总览”，点击“创建数据集”；

2.5、填写数据集名称后，点击“创建并导入”；

2.6、导入图片后，点击“确认并返回”；

2.7、点击“查看与标注”；

2.8、点击“添加标签”；

2.9、填入标签名称后，点击“确定”；

2.10、点击“标注图片”；

2.11、将每一张图片的缺口位置标注出来；

2.12、标注好之后的图片；

2.13、点击“我的模型”，点击“训练模型”；

2.14、个人信息可选“学生”，其它信息按情况填写好后，点击“完成创建”；

2.15、选择好要训练的数据集后，点击“下一步”；

2.16、训练方式选择“常规训练”，训练环境选择第一个后，点击“开始训练”；

2.17、等待训练完成；

2.18、训练完成，点击“校验”；

2.19、点击“启动模型校验服务”；

2.20、点击“点击添加图片”；

2.21、选择一张图片验证；

2.22、验证没有问题，可以点击“申请发布”；

2.23、填写“服务名称”和“接口地址”后，点击“提交申请”；

2.24、点击“服务详情”，点击“查看API文档”；

2.25、点击“EasyDL版控制台“；

2.26、登录之后，选择”公有云部署“，选择”应用列表“，点击”创建应用“；

2.27、填写”应用名称“，”应用归属“选择”个人“，简单填写一下”应用描述“，点击”立即创建“；

2.28、点击“返回应用列表”；

2.29、查看“API Key”，“Secret Key”值；

2.30、回到“接口赋权”页面，点击“物体检测API调用文档”，找到“请求代码示例”，点击“Python3”，复制代码；

"""
EasyDL 物体检测 调用模型公有云API Python3实现
"""

import json
import base64
import requests
"""
使用 requests 库发送请求
使用 pip（或者 pip3）检查我的 python3 环境是否安装了该库，执行命令
  pip freeze | grep requests
若返回值为空，则安装该库
  pip install requests
"""


# 目标图片的 本地文件路径，支持jpg/png/bmp格式
IMAGE_FILEPATH = "【您的测试图片地址，例如：./example.jpg】"

# 可选的请求参数
# threshold: 默认值为建议阈值，请在 我的模型-模型效果-完整评估结果-详细评估 查看建议阈值
PARAMS = {"threshold": 0.3}

# 服务详情 中的 接口地址
MODEL_API_URL = "【您的API地址】"

# 调用 API 需要 ACCESS_TOKEN。若已有 ACCESS_TOKEN 则于下方填入该字符串
# 否则，留空 ACCESS_TOKEN，于下方填入 该模型部署的 API_KEY 以及 SECRET_KEY，会自动申请并显示新 ACCESS_TOKEN
ACCESS_TOKEN = "【您的ACESS_TOKEN】"
API_KEY = "【您的API_KEY】"
SECRET_KEY = "【您的SECRET_KEY】"


print("1. 读取目标图片 '{}'".format(IMAGE_FILEPATH))
with open(IMAGE_FILEPATH, 'rb') as f:
    base64_data = base64.b64encode(f.read())
    base64_str = base64_data.decode('UTF8')
print("将 BASE64 编码后图片的字符串填入 PARAMS 的 'image' 字段")
PARAMS["image"] = base64_str


if not ACCESS_TOKEN:
    print("2. ACCESS_TOKEN 为空，调用鉴权接口获取TOKEN")
    auth_url = "https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials"\
               "&client_id={}&client_secret={}".format(API_KEY, SECRET_KEY)
    auth_resp = requests.get(auth_url)
    auth_resp_json = auth_resp.json()
    ACCESS_TOKEN = auth_resp_json["access_token"]
    print("新 ACCESS_TOKEN: {}".format(ACCESS_TOKEN))
else:
    print("2. 使用已有 ACCESS_TOKEN")


print("3. 向模型接口 'MODEL_API_URL' 发送请求")
request_url = "{}?access_token={}".format(MODEL_API_URL, ACCESS_TOKEN)
response = requests.post(url=request_url, json=PARAMS)
response_json = response.json()
response_str = json.dumps(response_json, indent=4, ensure_ascii=False)
print("结果:\n{}".format(response_str))

2.31、将“图片地址”，“API地址”，“ACESS_TOKEN”，“API_KEY”，“SECRET_KEY“等值替换成自己的

"""
EasyDL 物体检测 调用模型公有云API Python3实现
"""

import json
import base64
import requests
"""
使用 requests 库发送请求
使用 pip（或者 pip3）检查我的 python3 环境是否安装了该库，执行命令
  pip freeze | grep requests
若返回值为空，则安装该库
  pip install requests
"""


# 目标图片的 本地文件路径，支持jpg/png/bmp格式
IMAGE_FILEPATH = "images/1.png"

# 可选的请求参数
# threshold: 默认值为建议阈值，请在 我的模型-模型效果-完整评估结果-详细评估 查看建议阈值
PARAMS = {"threshold": 0.3}

# 服务详情 中的 接口地址
MODEL_API_URL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/detection/jdyanzheng"

# 调用 API 需要 ACCESS_TOKEN。若已有 ACCESS_TOKEN 则于下方填入该字符串
# 否则，留空 ACCESS_TOKEN，于下方填入 该模型部署的 API_KEY 以及 SECRET_KEY，会自动申请并显示新 ACCESS_TOKEN
ACCESS_TOKEN = ""
API_KEY = "替换API_KEY"
SECRET_KEY = "替换SECRET_KEY"


print("1. 读取目标图片 '{}'".format(IMAGE_FILEPATH))
with open(IMAGE_FILEPATH, 'rb') as f:
    base64_data = base64.b64encode(f.read())
    base64_str = base64_data.decode('UTF8')
print("将 BASE64 编码后图片的字符串填入 PARAMS 的 'image' 字段")
PARAMS["image"] = base64_str


if not ACCESS_TOKEN:
    print("2. ACCESS_TOKEN 为空，调用鉴权接口获取TOKEN")
    auth_url = "https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials"\
               "&client_id={}&client_secret={}".format(API_KEY, SECRET_KEY)
    auth_resp = requests.get(auth_url)
    auth_resp_json = auth_resp.json()
    ACCESS_TOKEN = auth_resp_json["access_token"]
    print("新 ACCESS_TOKEN: {}".format(ACCESS_TOKEN))
else:
    print("2. 使用已有 ACCESS_TOKEN")


print("3. 向模型接口 'MODEL_API_URL' 发送请求")
request_url = "{}?access_token={}".format(MODEL_API_URL, ACCESS_TOKEN)
response = requests.post(url=request_url, json=PARAMS)
response_json = response.json()
response_str = json.dumps(response_json, indent=4, ensure_ascii=False)
print("结果:\n{}".format(response_str))

2.32、运行之后，可显示缺口的坐标位置。

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~