增量式

当我们在浏览相关网页的时候会发现，某些网站定时会在原有网页数据的基础上更新一批数据，例如某电影网站会实时更新一批最近热门的电影。小说网站会根据作者创作的进度实时更新最新的章节数据等等。那么，类似的情景，当我们在爬虫的过程中遇到时，我们是不是需要定时更新程序以便能爬取到网站中最近更新的数据呢？

1. 增量式爬虫

• 概念：通过爬虫程序监测某网站数据更新的情况，以便可以爬取到该网站更新出的新数据。

• 如何进行增量式的爬取工作：

  • 在发送请求之前判断这个URL是不是之前爬取过

  • 在解析内容后判断这部分内容是不是之前爬取过

  • 写入存储介质时判断内容是不是已经在介质中存在

    • 分析：

      不难发现，其实增量爬取的核心是去重， 至于去重的操作在哪个步骤起作用，只能说各有利弊。在我看来，前两种思路需要根据实际情况取一个（也可能都用）。第一种思路适合不断有新页面出现的网站，比如说小说的新章节，每天的最新新闻等等；第二种思路则适合页面内容会更新的网站。第三个思路是相当于是最后的一道防线。这样做可以最大程度上达到去重的目的。

• 去重方法

  • 将爬取过程中产生的url进行存储，存储在redis的set中。当下次进行数据爬取时，首先对即将要发起的请求对应的url在存储的url的set中做判断，如果存在则不进行请求，否则才进行请求。

  • 对爬取到的网页内容进行唯一标识的制定，然后将该唯一表示存储至redis的set中。当下次爬取到网页数据的时候，在进行持久化存储之前，首先可以先判断该数据的唯一标识在redis的set中是否存在，在决定是否进行持久化存储。

2. 项目案例

- 需求：爬取4567tv网站中所有的电影详情数据。

爬虫文件：

 import scrapy
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider, Rule
 ​
 from redis import Redis
 from incrementPro.items import IncrementproItem
 class MovieSpider(CrawlSpider):
     name = 'movie'
     # allowed_domains = ['www.xxx.com']
     start_urls = ['http://www.4567tv.tv/frim/index7-11.html']
 ​
     rules = (
         Rule(LinkExtractor(allow=r'/frim/index7-d+.html'), callback='parse_item', follow=True),
     )
     #创建redis链接对象
     conn = Redis(host='127.0.0.1',port=6379)
     def parse_item(self, response):
         li_list = response.xpath('//li[@class="p1 m1"]')
         for li in li_list:
             #获取详情页的url
             detail_url = 'http://www.4567tv.tv'+li.xpath('./a/@href').extract_first()
             #将详情页的url存入redis的set中
             ex = self.conn.sadd('urls',detail_url)
             if ex == 1:
                 print('该url没有被爬取过，可以进行数据的爬取')
                 yield scrapy.Request(url=detail_url,callback=self.parst_detail)
             else:
                 print('数据还没有更新，暂无新数据可爬取！')
 ​
     #解析详情页中的电影名称和类型，进行持久化存储
     def parst_detail(self,response):
         item = IncrementproItem()
         item['name'] = response.xpath('//dt[@class="name"]/text()').extract_first()
         item['kind'] = response.xpath('//div[@class="ct-c"]/dl/dt[4]//text()').extract()
         item['kind'] = ''.join(item['kind'])
         yield item

管道文件： ​

 from redis import Redis
 class IncrementproPipeline(object):
     conn = None
     def open_spider(self,spider):
         self.conn = Redis(host='127.0.0.1',port=6379)
     def process_item(self, item, spider):
         dic = {
             'name':item['name'],
             'kind':item['kind']
         }
         print(dic)
         self.conn.lpush('movieData',dic)
         return item

- 需求：爬取糗事百科中的段子和作者数据。

爬虫文件：

 import scrapy
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider, Rule
 from incrementByDataPro.items import IncrementbydataproItem
 from redis import Redis
 import hashlib
 class QiubaiSpider(CrawlSpider):
     name = 'qiubai'
     # allowed_domains = ['www.xxx.com']
     start_urls = ['https://www.qiushibaike.com/text/']
 ​
     rules = (
         Rule(LinkExtractor(allow=r'/text/page/d+/'), callback='parse_item', follow=True),
         Rule(LinkExtractor(allow=r'/text/$'), callback='parse_item', follow=True),
     )
     #创建redis链接对象
     conn = Redis(host='127.0.0.1',port=6379)
     def parse_item(self, response):
         div_list = response.xpath('//div[@id="content-left"]/div')
 ​
         for div in div_list:
             item = IncrementbydataproItem()
             item['author'] = div.xpath('./div[1]/a[2]/h2/text() | ./div[1]/span[2]/h2/text()').extract_first()
             item['content'] = div.xpath('.//div[@class="content"]/span/text()').extract_first()
 ​
             #将解析到的数据值生成一个唯一的标识进行redis存储
             source = item['author']+item['content']
             source_id = hashlib.sha256(source.encode()).hexdigest()
             #将解析内容的唯一表示存储到redis的data_id中
             ex = self.conn.sadd('data_id',source_id)
 ​
             if ex == 1:
                 print('该条数据没有爬取过，可以爬取......')
                 yield item
             else:
                 print('该条数据已经爬取过了，不需要再次爬取了!!!')

管道文件：

 from redis import Redis
 class IncrementbydataproPipeline(object):
     conn = None
 ​
     def open_spider(self, spider):
         self.conn = Redis(host='127.0.0.1', port=6379)
 ​
     def process_item(self, item, spider):
         dic = {
             'author': item['author'],
             'content': item['content']
         }
         # print(dic)
         self.conn.lpush('qiubaiData', dic)
         return item

3. 实例（url去重）

• 爬虫文件

 import scrapy
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider, Rule
 from redis import Redis  # 为了连接数据库
 from increment1_Pro.items import Increment1ProItem
 class MovieSpider(CrawlSpider):
     name = 'movie'
     # allowed_domains = ['www.xxx.com']
     start_urls = ['https://www.4567tv.tv/index.php/vod/show/id/7.html']
 ​
     rules = (
         Rule(LinkExtractor(allow=r'/index.php/vod/show/id/7/page/d+.html'), callback='parse_item', follow=True),
     )
 ​
     def parse_item(self, response):
         # 连接对象
         conn = Redis(host='127.0.0.1',port=6379)
         detail_url_list = 'https://www.4567tv.tv'+response.xpath('//li[@class="col-md-6 col-sm-4 col-xs-3"]/div/a/@href').extract()
         # 发请求之前先确认url有没有爬过，处理办法就是把url存到数据库
         # 往redis的set存数据，如果存成功，返回1
         for url in detail_url_list:
             #ex == 1:set中没有存储url
             ex = conn.sadd('movies_url',url)  # sadd向集合添加一个或多个成员 redis集合
             # 如果等于1，把url存到集合中
             if ex == 1:
                 yield scrapy.Request(url=url,callback=self.parse_detail)
             else:
                 print('网站没有更新数据,暂无新数据可爬!')
 ​
     def parse_detail(self,response):
         item = Increment1ProItem()
         # 将解析到的电影名称赋值给item中的name属性值
         item['name'] = response.xpath('/html/body/div[1]/div/div/div/div[2]/h1/text()').extract_first()
         item['actor'] = response.xpath('/html/body/div[1]/div/div/div/div[2]/p[3]/a/text()').extract_first()
 ​
         yield item

• iterm

 import scrapy
 ​
 ​
 class Increment1ProItem(scrapy.Item):
     # define the fields for your item here like:
     name = scrapy.Field()
     actor = scrapy.Field()

• 管道

 from redis import Redis
 class Increment1ProPipeline(object):
     conn = None
     # 连接对象
     def open_spider(self,spider):
         self.conn = Redis(host='127.0.0.1',port=6379)
     # 将item中的数据存到数据库里
     def process_item(self, item, spider):
         # 把item中的两个值封装成字典 
         dic = {
              'name':item['name'],  # 电影名称
              'actor':item['actor']  # 演员
          }
         print('有新数据被爬取到,正在入库......')
         # 'movie_data' 队列起名
         self.conn.lpush('movie_data',item)
         return item

4. 实例（数据去重）

• 爬虫文件

 import scrapy
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider, Rule
 ​
 from increment2_Pro.items import Increment2ProItem
 from redis import Redis
 import hashlib
 class QiubaiSpider(CrawlSpider):
     name = 'qiubai'
     # allowed_domains = ['www.xxx.com']
     start_urls = ['https://www.qiushibaike.com/text/']
 ​
     rules = (
         Rule(LinkExtractor(allow=r'/text/page/d+/'), callback='parse_item', follow=True),
     )
 ​
     def parse_item(self, response):
 ​
         div_list = response.xpath('//div[@class="article block untagged mb15 typs_hot"]')
         conn = Redis(host='127.0.0.1',port=6379)
         for div in div_list:
             item = Increment2ProItem()
             item['content'] = div.xpath('.//div[@class="content"]/span//text()').extract()
             # 将列表转换成字符串
             item['content'] = ''.join(item['content'])
             # 第二个xpath是拿匿名用户
             item['author'] = div.xpath('./div/a[2]/h2/text() | ./div[1]/span[2]/h2/text()').extract_first()
             source = item['author']+item['content']
             # 自己制定了一种形式的数据指纹
             # b后面字符串是bytes类型，网络编程中，服务器和浏览器只认bytes 类型数据
             hashValue = hashlib.sha256(source.encode()).hexdigest()
             # 起一个se名 qiubai_hash
             ex = conn.sadd('qiubai_hash',hashValue)
             if ex == 1:
                 yield item
             else:
                 print('没有更新数据可爬!!!')

• item

 import scrapy
 ​
 ​
 class Increment2ProItem(scrapy.Item):
     # define the fields for your item here like:
     content = scrapy.Field()
     author = scrapy.Field()

• 管道

from redis import Redis
 class Increment2ProPipeline(object):
     conn = None
     def open_spider(self,spider):
         self.conn = Redis(host='127.0.0.1',port=6379)
     def process_item(self, item, spider):
         # 封装成字典 不能直接存item
         dic = {
             'author':item['author'],
             'content':item['content']
         }
         # 队列的名称叫 quibaidata
         self.conn.lpush('qiubaiData',dic)  # 这里的dic不能直接是item
         print('爬取到一条数据,正在入库......')
         return item