全国旗舰校区

不同学习城市 同样授课品质

北京

深圳

上海

广州

郑州

大连

武汉

成都

西安

杭州

青岛

重庆

长沙

哈尔滨

南京

太原

沈阳

合肥

贵阳

济南

下一个校区
就在你家门口
+
当前位置:首页  >  技术干货

20天学会爬虫之Scrapy框架通用爬虫CrawlSpider

发布时间:2022-09-20 14:48:03
发布人:qyf

  上篇文章给大家分享的是Spider类的使用,本次我们继续分享学习Spider类的子类CrawlSpider类。

  介绍CrawlSpider

  CrawlSpider其实是Spider的一个子类,除了继承到Spider的特性和功能外,还派生除了其自己独有的更加强大的特性和功能。

  比如如果你想爬取知乎或者是简书全站的话,CrawlSpider这个强大的武器就可以爬上用场了,说CrawlSpider是为全站爬取而生也不为过。

  其中最显著的功能就是”LinkExtractors链接提取器“。Spider是所有爬虫的基类,其设计原则只是为了爬取start_url列表中网页,而从爬取到的网页中提取出的url进行继续的爬取工作使用CrawlSpider更合适。

  CrawlSpider源码分析

  源码解析

  class CrawlSpider(Spider):

  rules = ()

  def __init__(self, *a, **kw):

  super(CrawlSpider, self).__init__(*a, **kw)

  self._compile_rules()

  # 首先调用parse()来处理start_urls中返回的response对象

  # parse()则将这些response对象传递给了_parse_response()函数处理,并设置回调函数为parse_start_url()

  # 设置了跟进标志位True

  # parse将返回item和跟进了的Request对象

  def parse(self, response):

  return self._parse_response(response, self.parse_start_url, cb_kwargs={}, follow=True)

  # 处理start_url中返回的response,需要重写

  def parse_start_url(self, response):

  return []

  def process_results(self, response, results):

  return results

  # 从response中抽取符合任一用户定义'规则'的链接,并构造成Resquest对象返回

  def _requests_to_follow(self, response):

  if not isinstance(response, HtmlResponse):

  return

  seen = set()

  # 抽取之内的所有链接,只要通过任意一个'规则',即表示合法

  for n, rule in enumerate(self._rules):

  links = [l for l in rule.link_extractor.extract_links(response) if l not in seen]

  # 使用用户指定的process_links处理每个连接

  if links and rule.process_links:

  links = rule.process_links(links)

  # 将链接加入seen集合,为每个链接生成Request对象,并设置回调函数为_repsonse_downloaded()

  for link in links:

  seen.add(link)

  # 构造Request对象,并将Rule规则中定义的回调函数作为这个Request对象的回调函数

  r = Request(url=link.url, callback=self._response_downloaded)

  r.meta.update(rule=n, link_text=link.text)

  # 对每个Request调用process_request()函数。该函数默认为indentify,即不做任何处理,直接返回该Request.

  yield rule.process_request(r)

  # 处理通过rule提取出的连接,并返回item以及request

  def _response_downloaded(self, response):

  rule = self._rules[response.meta['rule']]

  return self._parse_response(response, rule.callback, rule.cb_kwargs, rule.follow)

  # 解析response对象,会用callback解析处理他,并返回request或Item对象

  def _parse_response(self, response, callback, cb_kwargs, follow=True):

  # 首先判断是否设置了回调函数。(该回调函数可能是rule中的解析函数,也可能是 parse_start_url函数)

  # 如果设置了回调函数(parse_start_url()),那么首先用parse_start_url()处理response对象,

  # 然后再交给process_results处理。返回cb_res的一个列表

  if callback:

  #如果是parse调用的,则会解析成Request对象

  #如果是rule callback,则会解析成Item

  cb_res = callback(response, **cb_kwargs) or ()

  cb_res = self.process_results(response, cb_res)

  for requests_or_item in iterate_spider_output(cb_res):

  yield requests_or_item

  # 如果需要跟进,那么使用定义的Rule规则提取并返回这些Request对象

  if follow and self._follow_links:

  #返回每个Request对象

  for request_or_item in self._requests_to_follow(response):

  yield request_or_item

  def _compile_rules(self):

  def get_method(method):

  if callable(method):

  return method

  elif isinstance(method, basestring):

  return getattr(self, method, None)

  self._rules = [copy.copy(r) for r in self.rules]

  for rule in self._rules:

  rule.callback = get_method(rule.callback)

  rule.process_links = get_method(rule.process_links)

  rule.process_request = get_method(rule.process_request)

  def set_crawler(self, crawler):

  super(CrawlSpider, self).set_crawler(crawler)

  self._follow_links = crawler.settings.getbool('CRAWLSPIDER_FOLLOW_LINKS', True)

  CrawlSpider爬虫文件字段介绍

  CrawlSpider除了继承Spider类的属性:name、allow_domains之外,还提供了一个新的属性:rules。它是包含一个或多个Rule对象的集合。每个Rule对爬取网站的动作定义了特定规则。如果多个Rule匹配了相同的链接,则根据他们在本属性中被定义的顺序,第一个会被使用。

  CrawlSpider也提供了一个可复写的方法:

  parse_start_url(response)

  当start_url的请求返回时,该方法被调用。该方法分析最初的返回值并必须返回一个Item对象或一个Request对象或者一个可迭代的包含二者的对象。

  注意:当编写爬虫规则时,请避免使用parse 作为回调函数。 由于CrawlSpider使用parse 方法来实现其逻辑,如果 您覆盖了parse 方法,CrawlSpider将会运行失败。

  另外,CrawlSpider还派生了其自己独有的更加强大的特性和功能,最显著的功能就是”LinkExtractors链接提取器“。

  LinkExtractor

  class scrapy.linkextractors.LinkExtractor

  LinkExtractor是从网页(scrapy.http.Response)中抽取会被follow的链接的对象。目的很简单: 提取链接。每个LinkExtractor有唯一的公共方法是 extract_links(),它接收一个 Response 对象,并返回一个 scrapy.link.Link 对象

  即Link Extractors要实例化一次,并且 extract_links 方法会根据不同的 response 调用多次提取链接。源码如下:

  class scrapy.linkextractors.LinkExtractor(

  allow = (), # 满足括号中“正则表达式”的值会被提取,如果为空,则全部匹配。

  deny = (), # 与这个正则表达式(或正则表达式列表)不匹配的URL一定不提取。

  allow_domains = (), # 会被提取的链接的domains。

  deny_domains = (), # 一定不会被提取链接的domains。

  deny_extensions = None,

  restrict_xpaths = (), # 使用xpath表达式,和allow共同作用过滤链接

  tags = ('a','area'),

  attrs = ('href'),

  canonicalize = True,

  unique = True,

  process_value = None

  )

  作用:提取response中符合规则的链接。

  参考链接:https://scrapy-chs.readthedocs.io/zh_CN/latest/topics/link-extractors.html

  Rule类

  LinkExtractor是用来提取的类,但是提取的规则需要通过Rule类实现。Rule类的定义如下:

  class scrapy.contrib.spiders.Rule(link_extractor,callback=None,cb_kwargs=None,

  follow=None,process_links=None,process_request=None)

  参数如下:

  link_extractor:是一个Link Extractor对象。其定义了如何从爬取到的页面提取链接。

  callback:是一个callable或string(该Spider中同名的函数将会被调用)。从link_extractor中每获取到链接时将会调用该函数。该回调函数接收一个response作为其第一个参数,并返回一个包含Item以及Request对象(或者这两者的子类)的列表。

  cb_kwargs:包含传递给回调函数的参数(keyword argument)的字典。

  follow:是一个boolean值,指定了根据该规则从response提取的链接是否需要跟进。如果callback为None,follow默认设置True,否则默认False。

  processlinks:是一个callable或string(该Spider中同名的函数将会被调用)。从linkextrator中获取到链接列表时将会调用该函数。该方法主要是用来过滤。

  processrequest:是一个callable或string(该spider中同名的函数都将会被调用)。该规则提取到的每个request时都会调用该函数。该函数必须返回一个request或者None。用来过滤request。

  参考链接:https://scrapy-chs.readthedocs.io/zhCN/latest/topics/spiders.html#topics-spiders-ref

  通用爬虫案例

  CrawlSpider整体的爬取流程:

  爬虫文件首先根据url,获取该url的网页内容

  链接提取器会根据提取规则,对步骤1网页内容中的链接进行提取

  规则解析器会根据指定的解析规则,将链接提取器中提取到的链接按照指定的规则进行解析

  将3中解析的数据封装到item中,最后提交给管道进行持久化存储

  创建CrawlSpider爬虫项目

  创建scrapy工程:scrapy startproject projectName

  创建爬虫文件(切换到创建的项目下执行):scrapy genspider -t crawl spiderName www.xxx.com

  --此指令对比以前的指令多了 "-t crawl",表示创建的爬虫文件是基于CrawlSpider这个类的,而不再是Spider这个基类。

  启动爬虫文件(基于步骤二的路径执行):scrapy crawl crawlDemo

  案例(爬取小说案例)

  测试小说是否可用

  本案例是17k小说网小说爬取,打开首页---->选择:分类---->选择:已完本、只看免费,如下图:

Picture

  链接:https://www.17k.com/all/book/200030101.html

  按照上面的步骤我们依次:

  scrapy startproject seventeen_k

  scrapy genspider -t crawl novel www.17k.com

  Pycharm 打开项目

  查看novel.py

  class NovelSpider(CrawlSpider):

  name = 'novel'

  allowed_domains = ['www.17k.com']

  start_urls = ['https://www.17k.com/all/book/2_0_0_0_3_0_1_0_1.html']

  rules = (

  Rule(allow = LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrict_xpaths=('//td[@class="td3"]')),

  callback='parse_book',follow=True, process_links="process_booklink"),

  )

  def process_booklink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("限制一本书:", link.url)

  yield link

  else:

  return

  def parse_book(self, response):

  item = {

  return item

  首先测试一下是否可以爬取到内容,注意rules给出的规则:

  Rule(allow = LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrictxpaths=('//td[@class="td3"]')),

  callback='parsebook',follow=True, processlinks="processbooklink")

  在allow中指定了提取链接的正则表达式,相当于findall(r'正则内容',response.text),在LinkExtractor中添加了参数restrict_xpaths是为了与正则表达式搭配使用,更快的定位链接。

  callback='parse_item'是指定回调函数

  process_links用于处理LinkExtractor匹配到的链接的回调函数

  然后,配置settings.py里的必要配置后运行,即可发现指定页面第一本小说URL获取正常:

Picture(1)

  执行:scrapy crawl novel ,运行结果:

Picture(2)

  解析小说的详细信息

  上图链接对应小说的详情页: https://www.17k.com/book/3352644.html

Picture(3)

  通过解析书籍的URL的获取到的响应,获取以下数据:

  catagory(分类),bookname,status,booknums,description,ctime,bookurl,chapter_url

  改写parse_book函数内容如下:

  import scrapy

  from scrapy.linkextractors import LinkExtractor

  from scrapy.spiders import CrawlSpider, Rule

  class NovelSpider(CrawlSpider):

  name = 'novel'

  allowed_domains = ['www.17k.com']

  start_urls = ['https://www.17k.com/all/book/2_0_0_0_3_0_1_0_1.html']

  rules = (

  Rule(LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrict_xpaths=('//td[@class="td3"]')), callback='parse_book',

  follow=True, process_links="process_booklink"),

  )

  def process_booklink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("限制一本书:", link.url)

  yield link

  else:

  return

  def parse_book(self, response):

  item ={}

  print("解析book_url")

  # 字数:

  book_nums = response.xpath('//div[@class="BookData"]/p[2]/em/text()').extract()[0]

  # 书名:

  book_name = response.xpath('//div[@class="Info "]/h1/a/text()').extract()[0]

  # 分类

  category = response.xpath('//dl[@id="bookInfo"]/dd/div[2]/table//tr[1]/td[2]/a/text()').extract()[0]

  # 概述

  description = "".join(response.xpath('//p[@class="intro"]/a/text()').extract())

  # 小说链接

  book_url = response.url

  # 小说章节

  chapter_url = response.xpath('//dt[@class="read"]/a/@href').extract()[0]

  print(book_nums, book_url,book_name,category,description,chapter_url)

  return item

  打印结果:

Picture(4)

  解析章节信息

  通过解析书籍的URL获取的响应里解析得到每个小说章节列表页的URL,并发送请求获得响应,得到对应小说的章节列表页,获取以下数据:id , title(章节名称) content(内容),ordernum(序号),ctime,chapterurl(章节url),catalog_url(目录url)

  在novel.py的rules中添加:

  ...

  rules = (

  Rule(LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrict_xpaths=('//td[@class="td3"]')),

  callback='parse_book',

  follow=True, process_links="process_booklink"),

  # 匹配章节目录的url

  Rule(LinkExtractor(allow=r'/list/\d+.html',

  restrict_xpaths=('//dt[@class="read"]')), callback='parse_chapter', follow=True,

  process_links="process_chapterlink"),

  )

  def process_chapterlink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("章节:", link.url)

  yield link

  else:

  return

  ...

Picture(5)

  通过上图可以发现从上一个链接的response中,匹配第二个rule可以提取到章节的链接,继续编写解析章节详情的回调函数parse_chapter,代码如下:

  # 前面代码省略

  ......

  def parse_chapter(self, response):

  print("解析章节目录", response.url) # response.url就是数据的来源的url

  # 注意:章节和章节的url要一一对应

  a_tags = response.xpath('//dl[@class="Volume"]/dd/a')

  chapter_list = []

  for index, a in enumerate(a_tags):

  title = a.xpath("./span/text()").extract()[0].strip()

  chapter_url = a.xpath("./@href").extract()[0]

  ordernum = index + 1

  c_time = datetime.datetime.now()

  chapter_url_refer = response.url

  chapter_list.append([title, ordernum, c_time, chapter_url, chapter_url_refer])

  print('章节目录:', chapter_list)

  重新运行测试,发现数据获取正常!

Picture(6)

  获取章节详情

  通过解析对应小说的章节列表页获取到每一章节的URL,发送请求获得响应,得到对应章节的章节内容,同样添加章节的rule和回调函数.完整代码如下:

  import datetime

  import scrapy

  from scrapy.linkextractors import LinkExtractor

  from scrapy.spiders import CrawlSpider, Rule

  class NovelSpider(CrawlSpider):

  name = 'novel'

  allowed_domains = ['www.17k.com']

  start_urls = ['https://www.17k.com/all/book/2_0_0_0_3_0_1_0_1.html']

  rules = (

  Rule(LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrict_xpaths=('//td[@class="td3"]')),

  callback='parse_book',

  follow=True, process_links="process_booklink"),

  # 匹配章节目录的url

  Rule(LinkExtractor(allow=r'/list/\d+.html',

  restrict_xpaths=('//dt[@class="read"]')), callback='parse_chapter', follow=True,

  process_links="process_chapterlink"),

  # 解析章节详情

  Rule(LinkExtractor(allow=r'/chapter/(\d+)/(\d+).html',

  restrict_xpaths=('//dl[@class="Volume"]/dd')), callback='get_content',

  follow=False, process_links="process_chapterDetail"),

  )

  def process_booklink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("限制一本书:", link.url)

  yield link

  else:

  return

  def process_chapterlink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("章节:", link.url)

  yield link

  else:

  return

  def process_chapterDetail(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("章节详情:", link.url)

  yield link

  else:

  return

  def parse_book(self, response):

  print("解析book_url")

  # 字数:

  book_nums = response.xpath('//div[@class="BookData"]/p[2]/em/text()').extract()[0]

  # 书名:

  book_name = response.xpath('//div[@class="Info "]/h1/a/text()').extract()[0]

  # 分类

  category = response.xpath('//dl[@id="bookInfo"]/dd/div[2]/table//tr[1]/td[2]/a/text()').extract()[0]

  # 概述

  description = "".join(response.xpath('//p[@class="intro"]/a/text()').extract())

  # 小说链接

  book_url = response.url

  # 小说章节

  chapter_url = response.xpath('//dt[@class="read"]/a/@href').extract()[0]

  print(book_nums, book_url, book_name, category, description, chapter_url)

  def parse_chapter(self, response):

  print("解析章节目录", response.url) # response.url就是数据的来源的url

  # 注意:章节和章节的url要一一对应

  a_tags = response.xpath('//dl[@class="Volume"]/dd/a')

  chapter_list = []

  for index, a in enumerate(a_tags):

  title = a.xpath("./span/text()").extract()[0].strip()

  chapter_url = a.xpath("./@href").extract()[0]

  ordernum = index + 1

  c_time = datetime.datetime.now()

  chapter_url_refer = response.url

  chapter_list.append([title, ordernum, c_time, chapter_url, chapter_url_refer])

  print('章节目录:', chapter_list)

  def get_content(self, response):

  content = "".join(response.xpath('//div[@class="readAreaBox content"]/div[@class="p"]/p/text()').extract())

  print(content)

  同样发现数据是正常的,如下图:

Picture(7)

  进行数据的持久化,写入Mysql数据库

  a. 定义结构化字段(items.py文件的编写):

  class Seventeen_kItem(scrapy.Item):

  '''匹配每个书籍URL并解析获取一些信息创建的字段'''

  # define the fields for your item here like:

  # name = scrapy.Field()

  category = scrapy.Field()

  book_name = scrapy.Field()

  book_nums = scrapy.Field()

  description = scrapy.Field()

  book_url = scrapy.Field()

  chapter_url = scrapy.Field()

  class ChapterItem(scrapy.Item):

  '''从每个小说章节列表页解析当前小说章节列表一些信息所创建的字段'''

  # define the fields for your item here like:

  # name = scrapy.Field()

  chapter_list = scrapy.Field()

  class ContentItem(scrapy.Item):

  '''从小说具体章节里解析当前小说的当前章节的具体内容所创建的字段'''

  # define the fields for your item here like:

  # name = scrapy.Field()

  content = scrapy.Field()

  chapter_detail_url = scrapy.Field()

  b. 编写novel.py

  import datetime

  import scrapy

  from scrapy.linkextractors import LinkExtractor

  from scrapy.spiders import CrawlSpider, Rule

  from sevencat.items import Seventeen_kItem, ChapterItem, ContentItem

  class NovelSpider(CrawlSpider):

  name = 'novel'

  allowed_domains = ['www.17k.com']

  start_urls = ['https://www.17k.com/all/book/2_0_0_0_3_0_1_0_1.html']

  rules = (

  Rule(LinkExtractor(allow=r'//www.17k.com/book/\d+.html', restrict_xpaths=('//td[@class="td3"]')),

  callback='parse_book',

  follow=True, process_links="process_booklink"),

  # 匹配章节目录的url

  Rule(LinkExtractor(allow=r'/list/\d+.html',

  restrict_xpaths=('//dt[@class="read"]')), callback='parse_chapter', follow=True,

  process_links="process_chapterlink"),

  # 解析章节详情

  Rule(LinkExtractor(allow=r'/chapter/(\d+)/(\d+).html',

  restrict_xpaths=('//dl[@class="Volume"]/dd')), callback='get_content',

  follow=False, process_links="process_chapterDetail"),

  )

  def process_booklink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("限制一本书:", link.url)

  yield link

  else:

  return

  def process_chapterlink(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("章节:", link.url)

  yield link

  else:

  return

  def process_chapterDetail(self, links):

  for index, link in enumerate(links):

  # 限制一本书

  if index == 0:

  print("章节详情:", link.url)

  yield link

  else:

  return

  def parse_book(self, response):

  print("解析book_url")

  # 字数:

  book_nums = response.xpath('//div[@class="BookData"]/p[2]/em/text()').extract()[0]

  # 书名:

  book_name = response.xpath('//div[@class="Info "]/h1/a/text()').extract()[0]

  # 分类

  category = response.xpath('//dl[@id="bookInfo"]/dd/div[2]/table//tr[1]/td[2]/a/text()').extract()[0]

  # 概述

  description = "".join(response.xpath('//p[@class="intro"]/a/text()').extract())

  # # 小说链接

  book_url = response.url

  # 小说章节

  chapter_url = response.xpath('//dt[@class="read"]/a/@href').extract()[0]

  # print(book_nums, book_url, book_name, category, description, chapter_url)

  item = Seventeen_kItem()

  item['book_nums'] = book_nums

  item['book_name'] = book_name

  item['category'] = category

  item['description'] = description

  item['book_url'] = book_url

  item['chapter_url'] = chapter_url

  yield item

  def parse_chapter(self, response):

  print("解析章节目录", response.url) # response.url就是数据的来源的url

  # 注意:章节和章节的url要一一对应

  a_tags = response.xpath('//dl[@class="Volume"]/dd/a')

  chapter_list = []

  for index, a in enumerate(a_tags):

  title = a.xpath("./span/text()").extract()[0].strip()

  chapter_url = a.xpath("./@href").extract()[0]

  ordernum = index + 1

  c_time = datetime.datetime.now()

  chapter_url_refer = response.url

  chapter_list.append([title, ordernum, c_time, chapter_url, chapter_url_refer])

  # print('章节目录:', chapter_list)

  item = ChapterItem()

  item["chapter_list"] = chapter_list

  yield item

  def get_content(self, response):

  content = "".join(response.xpath('//div[@class="readAreaBox content"]/div[@class="p"]/p/text()').extract())

  chapter_detail_url = response.url

  # print(content)

  item = ContentItem()

  item["content"] = content

  item["chapter_detail_url"] = chapter_detail_url

  yield item

  c. 编写管道文件:

  import pymysql

  import logging

  from .items import Seventeen_kItem, ChapterItem, ContentItem

  logger = logging.getLogger(__name__) # 生成以当前文件名命名的logger对象。 用日志记录报错。

  class Seventeen_kPipeline(object):

  def open_spider(self, spider):

  # 连接数据库

  data_config = spider.settings["DATABASE_CONFIG"]

  if data_config["type"] == "mysql":

  self.conn = pymysql.connect(**data_config["config"])

  self.cursor = self.conn.cursor()

  def process_item(self, item, spider):

  # 写入数据库

  if isinstance(item, Seventeen_kItem):

  # 写入书籍信息

  sql = "select id from novel where book_name=%s and author=%s"

  self.cursor.execute(sql, (item["book_name"], ["author"]))

  if not self.cursor.fetchone(): # .fetchone()获取上一个查询结果集。在python中如果没有则为None

  try:

  # 如果没有获得一个id,小说不存在才进行写入操作

  sql = "insert into novel(category,book_name,book_nums,description,book_url,chapter_url)" \

  "values(%s,%s,%s,%s,%s,%s)"

  self.cursor.execute(sql, (

  item["category"],

  item["book_name"],

  item["book_nums"],

  item["description"],

  item["book_url"],

  item["catalog_url"],

  ))

  self.conn.commit()

  except Exception as e: # 捕获异常并日志显示

  self.conn.rollback()

  logger.warning("小说信息错误!url=%s %s") % (item["book_url"], e)

  return item

  elif isinstance(item, ChapterItem):

  # 写入章节信息

  try:

  sql = "insert into chapter (title,ordernum,c_time,chapter_url,chapter_url_refer)" \

  "values(%s,%s,%s,%s,%s)"

  # 注意:此处item的形式是! item["chapter_list"]====[(title,ordernum,c_time,chapter_url,chapter_url_refer)]

  chapter_list = item["chapter_list"]

  self.cursor.executemany(sql,

  chapter_list) # .executemany()的作用:一次操作,写入多个元组的数据。形如:.executemany(sql,[(),()])

  self.conn.commit()

  except Exception as e:

  self.conn.rollback()

  logger.warning("章节信息错误!%s" % e)

  return item

  elif isinstance(item, ContentItem):

  try:

  sql = "update chapter set content=%s where chapter_url=%s"

  content = item["content"]

  chapter_detail_url = item["chapter_detail_url"]

  self.cursor.execute(sql, (content, chapter_detail_url))

  self.conn.commit()

  except Exception as e:

  self.conn.rollback()

  logger.warning("章节内容错误!url=%s %s") % (item["chapter_url"], e)

  return item

  def close_spider(self, spider):

  # 关闭数据库

  self.cursor.close()

  self.conn.close()

  其中涉及到settings.py的配置:

  DATABASE_CONFIG={

  "type":"mysql",

  "config":{

  "host":"localhost",

  "port":3306,

  "user":"root",

  "password":"root",

  "db":"noveldb",

  "charset":"utf8"

  }

  }

  数据库的表分别为:

  novel表字段有:

  id(自动增长的)

  category

  book_name

  book_nums

  description

  book_url

  chapter_url

  chapter表字段有:

  id

  title

  ordernum

  c_time

  chapter_url

  chapter_url_refer

  conent

  如果想获取多页的小说则需要加入对start_urls处理的函数,通过翻页观察每页URL的规律,在此函数中拼接得到多页 的URL,并将请求发送给引擎!

  ......

  page_num = 1

  #start_urls的回调函数

  # 作用:拼接得到每页小说的url。实现多页小说获取。

  def parse_start_url(self, response):

  print(self.page_num,response)

  #可以解析star_urls的response 相当于之前的parse函数来用

  #拼接下一页的url

  self.page_num+=1

  next_pageurl='https://www.17k.com/all/book/2_0_0_0_3_0_1_0_{}.html'.format(self.page_num)

  if self.page_num==3:

  return

  yield scrapy.Request(next_pageurl)

  注意:在每个对应的processxxxx的回调函数中都是获取index=0的小说,文章等,可以修改比如processchapterlink中的index<=20,那就是更多的章节信息了。

Picture(8)

  ok抓紧时间测试一下吧!相信你会收获很多!

相关文章

计算机视觉中所指的深度和深度学习中的深度有什么区别?

计算机视觉中所指的深度和深度学习中的深度有什么区别?

2023-10-15
显著性目标检测和一般目标检测最本质的区别是什么区别?

显著性目标检测和一般目标检测最本质的区别是什么区别?

2023-10-15
在目标检测里single-shot和multi-shot的主要区别是什么?

在目标检测里single-shot和multi-shot的主要区别是什么?

2023-10-15
APP安全测试与普通B/S架构的渗透测试有什么区别?

APP安全测试与普通B/S架构的渗透测试有什么区别?

2023-10-15

最新文章

常见网络安全面试题:Windows常用的命令有哪些?

常见网络安全面试题:Windows常用的命令有哪些?

2023-10-09
常见网络安全面试题:根据设备告警如何展开排查?

常见网络安全面试题:根据设备告警如何展开排查?

2023-10-09
常见网络安全面试题:mysql加固呢?(数据库加固)

常见网络安全面试题:mysql加固呢?(数据库加固)

2023-10-09
常见网络安全面试题:windows和linux加固?(操作系统加固)

常见网络安全面试题:windows和linux加固?(操作系统加固)

2023-10-09
在线咨询 免费试学 教程领取