• selenium自动化测试+OCR-获取图片页面小说

    随着爬虫技术的发展，反爬虫技术也越来越高。

    目前有些网站通过自定义字体库的方式实现反爬，主要表现在页面数据显示正常，但是页面获取到的实际数据是别的字符或者是一个编码。
    这种反爬需要解析网站自己的字体库，对加密字符使用字体库对应字符替换。需要制作字体和基本字体间映射关系。
    还有些网站通过图片加载内容的方式实现反爬，想要获取网页内容，可以结合使用OCR技术获取图片文字内容。

    第一步：先获取网页内容截图

    结合之前《selenium自动化测试-获取动态页面小说》相关的文章代码，改造下，封装成一个新方法，只获取小说网页内容截图，按章节ID分目录保存每页截图文件。

    依旧采用拆分步骤细化功能模块封装方法编写代码，便于后续扩展功能模块，代码中缺少的封装方法代码，详情参考之前的《selenium自动化测试》文章。

    1. def spider_novel_content_save_image(req_dict):
    2.     '''
    3.     @方法名称: 爬取小说章节明细内容，保存内容截图文件
    4.     @中文注释: 爬取小说章节明细内容，保存内容截图文件
    5.     @入参:
    6.         @param req_dict dict 请求容器
    7.     @出参:
    8.         @返回状态:
    9.             @return 0 失败或异常
    10.             @return 1 成功
    11.         @返回错误码
    12.         @返回错误信息
    13.         @param rsp_dict dict 响应容器
    14.     @作    者: PandaCode辉
    15.     @weixin公众号: PandaCode辉
    16.     @创建时间: 2023-09-26
    17.     @使用范例: spider_novel_content_save_image(req_dict)
    18.     '''
    19.  
    20.     try:
    21.         if (not type(req_dict) is dict):
    22.             return [0, "111111", "请求容器参数类型错误,不为字典", [None]]
    23.         # 章节目录文件名
    24.         json_name = req_dict['novel_name'] + '.json'
    25.         # 检查文件是否存在
    26.         if os.path.isfile(json_name):
    27.             print('json文件存在，不用重新爬取小说目录.')
    28.         else:
    29.             print('json文件不存在')
    30.             # 爬取小说目录
    31.             spider_novel_mulu(req_dict)
    32.         # 读取json文件
    33.         with open(json_name, 'r') as f:
    34.             data_str = f.read()
    35.         # 转换为字典容器
    36.         mulu_dict = json.loads(data_str)
    37.  
    38.         # 在列表中查找指定元素的下标，未完成标志下标
    39.         flag_index = mulu_dict['flag'].index('0')
    40.         print(flag_index)
    41.         # 章节总数
    42.         chap_len = len(mulu_dict['chap_url'])
    43.         # 在列表中查找指定元素的下标
    44.         print('章节总数:', chap_len)
    45.  
    46.         # 截图目录
    47.         screenshot_dir = os.path.join(os.path.dirname(__file__), 'screenshot')
    48.         if not os.path.exists(screenshot_dir):
    49.             os.makedirs(screenshot_dir)
    50.  
    51.         print('打开浏览器驱动')
    52.         open_driver()
    53.         # 循环读取章节
    54.         for chap_id in range(flag_index, chap_len):
    55.             print('chap_id : ', chap_id)
    56.             # 章节url
    57.             chap_url = mulu_dict['chap_url'][chap_id]
    58.             # 截图目录，根据章节ID分类保存
    59.             chap_id_dir = os.path.join(screenshot_dir, str(chap_id))
    60.             if not os.path.exists(chap_id_dir):
    61.                 os.makedirs(chap_id_dir)
    62.             # 打开网址网页
    63.             print('打开网址网页')
    64.             driver.get(chap_url)
    65.             # 等待6秒启动完成
    66.             driver.implicitly_wait(6)
    67.             print('随机休眠')
    68.             # 随机休眠 暂停0-2秒的整数秒
    69.             time.sleep(random.randint(0, 2))
    70.  
    71.             # 章节分页url列表初始化
    72.             page_href_list = []
    73.             # 根据url地址获取网页信息
    74.             chap_rst = get_html_by_webdriver(chap_url)
    75.             time.sleep(3)
    76.             if chap_rst[0] != 1:
    77.                 # 跳出循环爬取
    78.                 break
    79.             chap_html_str = chap_rst[3][0]
    80.             # 使用BeautifulSoup解析网页数据
    81.             chap_soup = BeautifulSoup(chap_html_str, "html.parser")
    82.             # 章节内容分页数和分页url
    83.             # 获取分页页码标签下的href元素取出
    84.             page_href_list_tmp = chap_soup.select("div#PageSet > a")
    85.             all_page_cnt = len(page_href_list_tmp)
    86.             print("分页页码链接数量：" + str(all_page_cnt))
    87.             # 去除最后/后面数字+.html
    88.             tmp_chap_url = re.sub(r'(\d+\.html)', '', chap_url)
    89.             for each in page_href_list_tmp:
    90.                 if len(each) > 0:
    91.                     chap_url = tmp_chap_url + str(each.get('href'))
    92.                     print("拼接小说章节分页url链接：" + chap_url)
    93.                     # 判断是否已经存在列表中
    94.                     if not chap_url in page_href_list:
    95.                         page_href_list.append(chap_url)
    96.             print("分页url链接列表：" + str(page_href_list))
    97.  
    98.             # 网页长宽最大化，保证截图是完整的，不会出现滚动条
    99.             S = lambda X: driver.execute_script('return document.body.parentNode.scroll' + X)
    100.             driver.set_window_size(S('Width'), S('Height'))
    101.  
    102.             # 章节页码，首页
    103.             page_num = 1
    104.             # 章节内容截图
    105.             image_file = os.path.join(chap_id_dir, str(page_num) + '.png')
    106.             # 元素定位
    107.             chap_content_element = driver.find_element(By.ID, 'content')
    108.             print(chap_content_element)
    109.             # 元素截图
    110.             chap_content_element.screenshot(image_file)
    111.  
    112.             # 分页列表大于0
    113.             if len(page_href_list) > 0:
    114.                 for chap_url_page in page_href_list:
    115.                     print("chap_url_page：" + chap_url_page)
    116.                     time.sleep(3)
    117.  
    118.                     # 打开网址网页
    119.                     print('打开网址网页')
    120.                     driver.get(chap_url_page)
    121.                     # 等待6秒启动完成
    122.                     driver.implicitly_wait(6)
    123.                     print('随机休眠')
    124.                     # 随机休眠 暂停0-2秒的整数秒
    125.                     time.sleep(random.randint(0, 2))
    126.  
    127.                     # 章节页码
    128.                     page_num += 1
    129.                     # 章节内容截图
    130.                     image_file = os.path.join(chap_id_dir, str(page_num) + '.png')
    131.                     # 元素定位
    132.                     chap_content_element = driver.find_element(By.ID, 'content')
    133.                     print(chap_content_element)
    134.                     # 元素截图
    135.                     chap_content_element.screenshot(image_file)
    136.  
    137.             # 爬取明细章节内容截图成功后，更新对应标志为-2-截图已完成
    138.             mulu_dict['flag'][chap_id] = '2'
    139.         print('关闭浏览器驱动')
    140.         close_driver()
    141.  
    142.         # 转换为json字符串
    143.         json_str = json.dumps(mulu_dict)
    144.         # 再次写入json文件，保存更新处理完标志
    145.         with open(json_name, 'w', encoding="utf-8") as json_file:
    146.             json_file.write(json_str)
    147.         print("再次写入json文件，保存更新处理完标志")
    148.         # 返回容器
    149.         return [1, '000000', '爬取小说内容截图成功', [None]]
    150.  
    151.     except Exception as e:
    152.         print('关闭浏览器驱动')
    153.         close_driver()
    154.         # 转换为json字符串
    155.         json_str = json.dumps(mulu_dict)
    156.         # 再次写入json文件，保存更新处理完标志
    157.         with open(json_name, 'w', encoding="utf-8") as json_file:
    158.             json_file.write(json_str)
    159.         print("再次写入json文件，保存更新处理完标志")
    160.         print("爬取小说内容异常," + str(e))
    161.         return [0, '999999', "爬取小说内容截图异常," + str(e), [None]]

    第二步：通过OCR接口识别截图

    结合之前《PaddleOCR学习笔记3-通用识别服务》和《selenium自动化测试-获取动态页面小说》相关的文章代码，改造下，封装成一个新方法，通过OCR接口识别小说网页内容截图，然后写入文件保存。

    依旧采用拆分步骤细化功能模块封装方法编写代码，便于后续扩展功能模块，代码中缺少的封装方法代码，详情参考之前的《selenium自动化测试》文章。

    1. # 模拟http请求
    2. def requests_http(file_path, file_name, url):
    3.     full_file_path = os.path.join(file_path, file_name)
    4.     # 请求参数，文件名
    5.     req_data = {'upload_file': open(full_file_path, 'rb')}
    6.  
    7.     # 模拟http请求
    8.     rsp_data = requests.post(url, files=req_data)
    9.     # print(rsp_data.text)
    10.     result_dict = json.loads(rsp_data.text)
    11.     # print(result_dict)
    12.     return result_dict
    13.  
    14.  
    15. def spider_novel_content_by_ocr(req_dict):
    16.     '''
    17.     @方法名称: 通过OCR接口获取小说章节明细内容文字
    18.     @中文注释: 读取章节列表json文件，通过OCR接口获取小说章节明细内容文字，保存到文本文件
    19.     @入参:
    20.         @param req_dict dict 请求容器
    21.     @出参:
    22.         @返回状态:
    23.             @return 0 失败或异常
    24.             @return 1 成功
    25.         @返回错误码
    26.         @返回错误信息
    27.         @param rsp_dict dict 响应容器
    28.     @作    者: PandaCode辉
    29.     @weixin公众号: PandaCode辉
    30.     @创建时间: 2023-09-26
    31.     @使用范例: spider_novel_content_by_ocr(req_dict)
    32.     '''
    33.  
    34.     try:
    35.         if (not type(req_dict) is dict):
    36.             return [0, "111111", "请求容器参数类型错误,不为字典", [None]]
    37.         # 章节目录文件名
    38.         json_name = req_dict['novel_name'] + '.json'
    39.         # 检查文件是否存在
    40.         if os.path.isfile(json_name):
    41.             print('json文件存在，不用重新爬取小说目录.')
    42.         else:
    43.             print('json文件不存在')
    44.             # 爬取小说目录
    45.             spider_novel_mulu(req_dict)
    46.         # 读取json文件
    47.         with open(json_name, 'r') as f:
    48.             data_str = f.read()
    49.         # 转换为字典容器
    50.         mulu_dict = json.loads(data_str)
    51.         """
    52.             关于open()的mode参数：
    53.             'r'：读
    54.             'w'：写
    55.             'a'：追加
    56.             'r+' == r+w（可读可写，文件若不存在就报错(IOError)）
    57.             'w+' == w+r（可读可写，文件若不存在就创建）
    58.             'a+' ==a+r（可追加可写，文件若不存在就创建）
    59.             对应的，如果是二进制文件，就都加一个b就好啦：
    60.             'rb'　　'wb'　　'ab'　　'rb+'　　'wb+'　　'ab+'
    61.         """
    62.         file_name = req_dict['novel_name'] + '.txt'
    63.         # 在列表中查找指定元素的下标，2-截图完成，标志下标
    64.         flag_index = mulu_dict['flag'].index('2')
    65.         print(flag_index)
    66.         # 2-截图完成，标志下标为0，则为第一次爬取章节内容，否则已经写入部分，只能追加内容写入文件
    67.         # 因为章节明细内容很多，防止爬取过程中间中断，重新爬取，不用重复再爬取之前成功写入的数据
    68.         if flag_index == 0:
    69.             # 打开文件，首次创建写入
    70.             fo = open(file_name, "w+", encoding="utf-8")
    71.         else:
    72.             # 打开文件，再次追加写入
    73.             fo = open(file_name, "a+", encoding="utf-8")
    74.         # 章节总数
    75.         chap_len = len(mulu_dict['chap_url'])
    76.         # 在列表中查找指定元素的下标
    77.         print('章节总数:', chap_len)
    78.  
    79.         # 截图目录
    80.         screenshot_dir = os.path.join(os.path.dirname(__file__), 'screenshot')
    81.         # 循环读取章节
    82.         for chap_id in range(flag_index, chap_len):
    83.             # 识别成功标志
    84.             succ_flag = False
    85.             # 章节标题
    86.             chap_title = mulu_dict['chap_title'][chap_id]
    87.             print('chap_id : ', chap_id)
    88.             # # 写入文件,章节标题
    89.             fo.write("\n" + chap_title + "\r\n")
    90.             # 截图目录，根据章节ID分类保存
    91.             chap_id_dir = os.path.join(screenshot_dir, str(chap_id))
    92.             # 列出目录下的所有文件和文件夹
    93.             file_list = os.listdir(chap_id_dir)
    94.             # 章节目录下文件列表大于0
    95.             if len(file_list) > 0:
    96.                 for file_name in file_list:
    97.                     print("file_name：" + file_name)
    98.                     time.sleep(3)
    99.  
    100.                     url = "http://127.0.0.1:5000/upload/"
    101.                     # 模拟http请求
    102.                     result_dict = requests_http(chap_id_dir, file_name, url)
    103.                     print(result_dict)
    104.                     # 识别成功
    105.                     if result_dict['error_code'] == '000000':
    106.                         succ_flag = True
    107.                         result_list = result_dict['result']
    108.                         for data in result_list:
    109.                             print(data['text'])
    110.                             # 将识别结果，逐行写入文件,章节内容
    111.                             fo.write(data['text'] + "\n")
    112.                     else:
    113.                         succ_flag = False
    114.                         print('识别失败异常.')
    115.             # 识别成功则更新
    116.             if succ_flag:
    117.                 # 爬取明细章节内容成功后，更新对应标志为-1-已完成
    118.                 mulu_dict['flag'][chap_id] = '1'
    119.         print('关闭浏览器驱动')
    120.         close_driver()
    121.         # 关闭文件
    122.         fo.close()
    123.         print("循环爬取明细章节内容，写入文件完成")
    124.         # 转换为json字符串
    125.         json_str = json.dumps(mulu_dict)
    126.         # 再次写入json文件，保存更新处理完标志
    127.         with open(json_name, 'w', encoding="utf-8") as json_file:
    128.             json_file.write(json_str)
    129.         print("再次写入json文件，保存更新处理完标志")
    130.         # 返回容器
    131.         return [1, '000000', '爬取小说内容成功', [None]]
    132.  
    133.     except Exception as e:
    134.         print('关闭浏览器驱动')
    135.         close_driver()
    136.         # 关闭文件
    137.         fo.close()
    138.         # 转换为json字符串
    139.         json_str = json.dumps(mulu_dict)
    140.         # 再次写入json文件，保存更新处理完标志
    141.         with open(json_name, 'w', encoding="utf-8") as json_file:
    142.             json_file.write(json_str)
    143.         print("再次写入json文件，保存更新处理完标志")
    144.         print("爬取小说内容异常," + str(e))
    145.         return [0, '999999', "爬取小说内容异常," + str(e), [None]]

    第三步：运行效果

    第四步：总结

    目前很多网站都有基本的反爬策略，常见就是验证码、JS参数加密这两种。
    爬虫本身会对网站增加一定的压力，所以也应该合理设定爬取速率，尽量避免对目标网站造成麻烦，影响网站正常使用，一定注意自己爬虫的姿势。

    敬畏法律，遵纪守法，从我做起。

     最后说明：上述文章仅供学习参考，请勿用于商业用途，感谢阅读。

  • 相关阅读:
    java计算机毕业设计基于ssm的少儿编程管理系统(源代码+数据库+Lw文档）
    Vmware通过VMware tools设置共享文件夹
    uniapp：启动图 .9png 制作教程
    Python爬虫教程：从入门到实战
    go 递归 数据多层级横向展开 插入数据库
    html_语义化标签
    Java基础——Java语言与面向对象
    一文了解 Java 中的构造器
    从零手写实现 nginx-25-directive map 条件判断指令
    spring boot自动装配及自动装配条件判断
  • 原文地址：https://blog.csdn.net/xionghui2007/article/details/133313572