• bs4库爬取小说工具

    学习了爬取天气预报，今天尝试做个爬取小说工具，有时候网上看看小说休闲下，打算保存txt文本文件，方便离线阅读。

    第一步：先确定目标网址

    网上随便找了本小说，先找到小说目录页面。

    网址首页：'https://www.douyinxs.com'

    目标小说目录页：'https://www.douyinxs.com/bqg/1081818/'

    第二步：再定位章节目录url

    按F12,确定章节位置。

     章节目录url定位： "div#list > dl > dd > a"

    第三步：再定位章节明细内容

    按F12,确定章节内容位置。

    第四步：编写代码

    采用2步爬取策略：

    1，先爬取小说章节目录url和标题信息保存json文件。

    2，再读取章节目录json文件，循环一条条爬取章节明细内容信息，写入txt文件中。

    3，章节明细数量太多，很容易出现异常情况，增加了异常重发处理机制。

    requests_bs4.py :

    1. # -*- coding: UTF-8 -*-
    2. # 爬取静态网页工具
    3. import requests
    4. import time
    5. import re
    6. from bs4 import BeautifulSoup
    7. import random
    8. import json
    9. import os
    10.  
    11.  
    12. def get_html_text(url):
    13.     '''
    14.     @方法名称: 获取网页的html信息
    15.     @中文注释: 获取网页的html信息,转换成字符串格式数据
    16.     @入参:
    17.         @param url str 网址
    18.     @出参:
    19.         @返回状态:
    20.             @return 0 失败或异常
    21.             @return 1 成功
    22.         @返回错误码
    23.         @返回错误信息
    24.         @param rsp_text str 网页html信息
    25.     @作    者: PandaCode辉
    26.     @创建时间: 2023-09-05
    27.     @使用范例: get_html_text('https://www.baidu.com/')
    28.     '''
    29.     try:
    30.         if (not type(url) is str):
    31.             return [0, "111111", "网址参数类型错误,不为字符串", [None]]
    32.  
    33.         # 浏览器用户信息列表
    34.         user_agents = [
    35.             'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11',
    36.             'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0',
    37.             'Opera/9.25 (Windows NT 5.1; U; en)',
    38.             'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)',
    39.             'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)',
    40.             'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12',
    41.             'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9',
    42.             'Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7',
    43.             'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0',
    44.         ]
    45.         # 随机获取一个浏览器用户信息
    46.         agent = random.choice(user_agents)
    47.         # header头信息
    48.         headers = {
    49.             'User-Agent': agent,
    50.             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    51.             'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',
    52.             'Accept-Encoding': 'gzip, deflate',
    53.             'Connection': 'keep-alive',
    54.             'Cache-Control': 'max-age=0',
    55.         }
    56.         # 代理IP地址，需要找到可用的代理ip，不然无法使用
    57.         # proxy = {'HTTP': 'xx.xx.xx.xx:8000', 'HTTPS': 'xx.xx.xx.xx:80'}
    58.         # response = requests.get(url, headers=headers, proxies=proxy, timeout=30)
    59.         # 增加随机模拟浏览器访问header头信息，提高反爬网站成功率
    60.         response = requests.get(url, headers=headers, timeout=30)
    61.         # print(response.status_code)
    62.         response.raise_for_status()
    63.         response.encoding = 'utf-8'
    64.         rsp_text = response.text
    65.         # 返回容器
    66.         return [1, '000000', '获取网页的html信息成功', [rsp_text]]
    67.  
    68.     except Exception as e:
    69.         print("获取网页的html信息异常," + str(e))
    70.         return [0, '999999', "获取网页的html信息异常," + str(e), [None]]
    71.  
    72.  
    73.  
    74. def spider_novel_mulu(req_dict):
    75.     '''
    76.     @方法名称: 爬取小说章节目录
    77.     @中文注释: 根据参数爬取小说目录，保存到json文件
    78.     @入参:
    79.         @param req_dict dict 请求容器
    80.     @出参:
    81.         @返回状态:
    82.             @return 0 失败或异常
    83.             @return 1 成功
    84.         @返回错误码
    85.         @返回错误信息
    86.         @param rsp_dict dict 响应容器
    87.     @作    者: PandaCode辉
    88.     @创建时间: 2023-09-06
    89.     @使用范例: spider_novel_mulu(req_dict)
    90.     '''
    91.  
    92.     try:
    93.         if (not type(req_dict) is dict):
    94.             return [0, "111111", "请求容器参数类型错误,不为字典", [None]]
    95.         # 目录分页，1-首页，2-下一页
    96.         mulu_page = '1'
    97.         url = req_dict['mulu_url']
    98.         # 章节目录汇总列表
    99.         tar_dir_href_list = []
    100.         i = 1
    101.         del_index = 0
    102.         # 遍历目录分页
    103.         while (True):
    104.             # 根据url地址获取网页信息
    105.             rst = get_html_text(url)
    106.             if rst[0] != 1:
    107.                 return rst
    108.             html_str = rst[3][0]
    109.             # 使用BeautifulSoup解析网页数据
    110.             soup = BeautifulSoup(html_str, "html.parser")
    111.  
    112.             # 目录列表地址
    113.             tar_dir_href = soup.select(req_dict['tar_dir_href'])
    114.             # print(tar_dir_href)
    115.             # tar_len = len(tar_dir_href)
    116.             # print('初始爬取章节总数量:', tar_len)
    117.             # 目录分页，1-首页，2-下一页
    118.             if mulu_page == '1':
    119.                 for dir_href in tar_dir_href:
    120.                     chap_title = dir_href.text
    121.                     # print(chap_title)
    122.                     if '第1章' in chap_title:
    123.                         break
    124.                     del_index += 1
    125.                 # 过滤章节下标
    126.                 print(del_index)
    127.                 # 过滤章节，从第一章开始
    128.                 tar_dir_href_list = tar_dir_href[del_index:]
    129.                 tar_len = len(tar_dir_href_list)
    130.                 print('过滤后章节总数量:', tar_len)
    131.                 # 目录分页，1-首页，2-下一页
    132.                 mulu_page = '2'
    133.             else:
    134.                 # 过滤章节，从第一章开始
    135.                 tar_dir_href = tar_dir_href[del_index:]
    136.                 # 判断一个list是否包含另一个list的全部元素
    137.                 is_in_list = [False for tmp in tar_dir_href if tmp not in tar_dir_href_list]
    138.                 if is_in_list:
    139.                     print('tar_dir_href_list 不包含 tar_dir_href 的所有元素！可以合并添加列表')
    140.                     # 合并列表
    141.                     tar_dir_href_list.extend(tar_dir_href)
    142.                     tar_len = len(tar_dir_href)
    143.                     print('过滤后章节总数量:', tar_len)
    144.                 else:
    145.                     print('tar_dir_href_list 包含 tar_dir_href 的所有元素！跳出循环，结束。')
    146.                     break
    147.             # 目录下一页url
    148.             # 'https://www.douyinxs.com/bqg/1081818_10/'
    149.             i += 1
    150.             url = req_dict['mulu_url'][:-1] + '_' + str(i) + '/'
    151.             print('目录下一页url: ' + url)
    152.         tar_len = len(tar_dir_href_list)
    153.         print('合并后章节总数量:', tar_len)
    154.         # 目录容器
    155.         mulu_dict = {}
    156.         # 章节标题，列表
    157.         mulu_dict['chap_title'] = []
    158.         # 章节url，列表
    159.         mulu_dict['chap_url'] = []
    160.         # 是否完成标志: 0-未完成,1-已完成，列表
    161.         mulu_dict['flag'] = []
    162.         # 循环读取章节
    163.         for dir_href in tar_dir_href_list:
    164.             # 章节标题
    165.             chap_title = dir_href.text
    166.             print(chap_title)
    167.             mulu_dict['chap_title'].append(chap_title)
    168.             # 章节url
    169.             chap_url = req_dict['novel_url'] + dir_href['href']
    170.             print(chap_url)
    171.             mulu_dict['chap_url'].append(chap_url)
    172.             mulu_dict['flag'].append('0')
    173.         # 转换为json字符串
    174.         json_str = json.dumps(mulu_dict)
    175.         json_name = req_dict['novel_name'] + '.json'
    176.         # 写入json文件
    177.         with open(json_name, 'w', encoding="utf-8") as json_file:
    178.             json_file.write(json_str)
    179.         # 返回容器
    180.         return [1, '000000', '爬取小说目录成功', [None]]
    181.  
    182.     except Exception as e:
    183.         print("爬取小说目录异常," + str(e))
    184.         return [0, '999999', "爬取小说目录异常," + str(e), [None]]
    185.  
    186.  
    187. def spider_novel_content(req_dict):
    188.     '''
    189.     @方法名称: 爬取小说章节明细内容
    190.     @中文注释: 读取章节列表json文件，爬取小说章节明细内容，保存到文本文件
    191.     @入参:
    192.         @param req_dict dict 请求容器
    193.     @出参:
    194.         @返回状态:
    195.             @return 0 失败或异常
    196.             @return 1 成功
    197.         @返回错误码
    198.         @返回错误信息
    199.         @param rsp_dict dict 响应容器
    200.     @作    者: PandaCode辉
    201.     @创建时间: 2023-09-06
    202.     @使用范例: spider_novel_content(req_dict)
    203.     '''
    204.  
    205.     try:
    206.         if (not type(req_dict) is dict):
    207.             return [0, "111111", "请求容器参数类型错误,不为字典", [None]]
    208.         # 章节目录文件名
    209.         json_name = req_dict['novel_name'] + '.json'
    210.         # 检查文件是否存在
    211.         if os.path.isfile(json_name):
    212.             print('json文件存在，不用重新爬取小说目录.')
    213.         else:
    214.             print('json文件不存在')
    215.             # 爬取小说目录
    216.             spider_novel_mulu(req_dict)
    217.         # 读取json文件
    218.         with open(json_name, 'r') as f:
    219.             data_str = f.read()
    220.         # 转换为字典容器
    221.         mulu_dict = json.loads(data_str)
    222.         """
    223.             关于open()的mode参数：
    224.             'r'：读
    225.             'w'：写
    226.             'a'：追加
    227.             'r+' == r+w（可读可写，文件若不存在就报错(IOError)）
    228.             'w+' == w+r（可读可写，文件若不存在就创建）
    229.             'a+' ==a+r（可追加可写，文件若不存在就创建）
    230.             对应的，如果是二进制文件，就都加一个b就好啦：
    231.             'rb'　　'wb'　　'ab'　　'rb+'　　'wb+'　　'ab+'
    232.         """
    233.         file_name = req_dict['novel_name'] + '.txt'
    234.         # 在列表中查找指定元素的下标，未完成标志下标
    235.         flag_index = mulu_dict['flag'].index('0')
    236.         print(flag_index)
    237.         # 未完成标志下标为0，则为第一次爬取章节内容，否则已经写入部分，只能追加内容写入文件
    238.         # 因为章节明细内容很多，防止爬取过程中间中断，重新爬取，不用重复再爬取之前成功写入的数据
    239.         if flag_index == 0:
    240.             # 打开文件，首次创建写入
    241.             fo = open(file_name, "w+", encoding="utf-8")
    242.         else:
    243.             # 打开文件，再次追加写入
    244.             fo = open(file_name, "a+", encoding="utf-8")
    245.         # 章节总数
    246.         chap_len = len(mulu_dict['chap_url'])
    247.         # 在列表中查找指定元素的下标
    248.         print('章节总数:', chap_len)
    249.         out_flag = False
    250.         # 循环读取章节
    251.         for i in range(flag_index, chap_len):
    252.             # 章节标题
    253.             chap_title = mulu_dict['chap_title'][i]
    254.             print(chap_title)
    255.             # 写入文件,章节标题
    256.             fo.write(chap_title + "\r\n")
    257.             # 章节url
    258.             chap_url = mulu_dict['chap_url'][i]
    259.             # 章节内容分页数
    260.             for j in range(2):
    261.                 if j > 0:
    262.                     # 章节内容下一页url
    263.                     chap_url = mulu_dict['chap_url'][i][:-5] + '_' + str(j + 1) + '.html'
    264.                 print(chap_url)
    265.                 # 再爬取明细章节内容
    266.                 # 根据url地址获取网页信息
    267.                 chap_rst = get_html_text(chap_url)
    268.                 if chap_rst[0] != 1:
    269.                     # 跳出循环爬取
    270.                     out_flag = True
    271.                     break
    272.                 chap_html_str = chap_rst[3][0]
    273.                 # 使用BeautifulSoup解析网页数据
    274.                 chap_soup = BeautifulSoup(chap_html_str, "html.parser")
    275.                 # 章节内容
    276.                 chap_content = chap_soup.select(req_dict['chap_content'])[0].text
    277.                 chap_content = chap_content.replace('    ', '\n').replace('  ', '\n')
    278.                 # print(chap_content)
    279.                 # 写入文件,章节内容
    280.                 fo.write(chap_content + "\r\n")
    281.             # 跳出循环爬取标志
    282.             if out_flag:
    283.                 print("跳出循环爬取标志")
    284.                 break
    285.             # 爬取明细章节内容成功后，更新对应标志为-1-已完成
    286.             mulu_dict['flag'][i] = '1'
    287.         # 关闭文件
    288.         fo.close()
    289.         print("循环爬取明细章节内容，写入文件完成")
    290.         # 转换为json字符串
    291.         json_str = json.dumps(mulu_dict)
    292.         # 再次写入json文件，保存更新处理完标志
    293.         with open(json_name, 'w', encoding="utf-8") as json_file:
    294.             json_file.write(json_str)
    295.         print("再次写入json文件，保存更新处理完标志")
    296.         # 返回容器
    297.         return [1, '000000', '爬取小说内容成功', [None]]
    298.  
    299.     except Exception as e:
    300.         # 转换为json字符串
    301.         json_str = json.dumps(mulu_dict)
    302.         # 再次写入json文件，保存更新处理完标志
    303.         with open(json_name, 'w', encoding="utf-8") as json_file:
    304.             json_file.write(json_str)
    305.         print("再次写入json文件，保存更新处理完标志")
    306.         print("爬取小说内容异常," + str(e))
    307.         return [0, '999999', "爬取小说内容异常," + str(e), [None]]
    308.  
    309.  
    310. # 主方法
    311. if __name__ == '__main__':
    312.  
    313.  
    314.     req_dict = {}
    315.     req_dict['novel_name'] = '重生八八从木匠开始'
    316.     req_dict['novel_url'] = 'https://www.douyinxs.com'
    317.     # 目录页面地址，第1页
    318.     req_dict['mulu_url'] = 'https://www.douyinxs.com/bqg/1081818/'
    319.     # 章节目录定位
    320.     req_dict['tar_dir_href'] = "div#list > dl > dd > a"
    321.     # 章节明细内容定位
    322.     req_dict['chap_content'] = 'article#content'
    323.     # 爬取小说目录
    324.     # spider_novel_mulu(req_dict)
    325.     # 爬取小说内容
    326.     spider_novel_content(req_dict)

  • 相关阅读:
    初级项目经理 如何快速提升能力?
    TCP详解之三次握手和四次挥手
    Android studio将一个项目作为module导入另一个项目
    WebDAV之π-Disk派盘 + PassStore
    Spring Boot 整合 Camunda 实现工作流
    如何设置 Jenkins 流水线环境变量
    字符串处理
    安装gstreamer开发依赖库到项目sysroot目录
    Webservice接口-WSDL文档【Webservice】
    详解编译和链接！
  • 原文地址：https://blog.csdn.net/xionghui2007/article/details/132754900