Python爬虫 - scrapy框架的基本操作

scrapy异步的爬虫框架。

• 异步的爬虫框架。

  • 高性能的数据解析，持久化存储，全栈数据的爬取，中间件，分布式

• 框架：就是一个集成好了各种功能且具有很强通用性的一个项目模板。

• 环境安装：
  Linux：

  pip3 install scrapy

Windows：

a. pip3 install wheel

  b. 下载twisted http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted

  c. 进入下载目录，执行 pip3 install Twisted?17.1.0?cp35?cp35m?win_amd64.whl

  d. pip3 install pywin32

  e. pip3 install scrapy

• 基本使用

  • 1.新建一个工程：scrapy startporject proName

    • settings.py:当前工程的配置文件
    • spiders：爬虫包，必须要存放一个或者多个爬虫文件（.py）

  • 2.cd proName

  • 3.scrapy genspider spiderName www.xxx.com

  • 4.执行工程：scrapy crawl spiderName

  • settings.py:

    • 不遵从robots协议
    • UA伪装
    • 指定日志输出的类型：LOG_LEVEL = ‘ERROR‘

• 数据解析：

  • 1.response.xpath(‘xpath表达式‘)
  • 2.scrapy中的xpath解析，在进行数据提取的时候，xpath方法返回的列表中存储的不再是字符串，
    而是存储的Selector对象，相关的字符串数据是存储在Selector对象的data参数中，我们必须使用
    extract()/extract_first()进行字符串数据的提取
  • extract()：可以作用到列表中的每一个列表元素中，返回的依然是一个列表
  • extract_first()：只可以作用到列表中的第一个列表元素中，返回的是字符串

• 持久化存储

  • 基于终端指令的持久化存储
    • 只可以将parse方法的返回值存储到指定后缀的文本文件中。
    • scrapy crawl spiderName -o ./duanzi.csv
  • 基于管道的持久化存储

# -*- coding: utf-8 -*-
import scrapy


class FirstSpider(scrapy.Spider):
    #爬虫名称：当前爬虫文件的唯一标识
    name = ‘first‘
    #允许的域名
    # allowed_domains = [‘www.baidu.com‘]
    #起始的url列表：列表元素只可以是url
    #作用：列表元素表示的url就会被进行请求发送
    start_urls = [‘http://duanziwang.com/category/%E7%BB%8F%E5%85%B8%E6%AE%B5%E5%AD%90/‘]
    #数据解析
    #调用次数是由请求次数决定
    # def parse(self, response):
    #     article_list = response.xpath(‘/html/body/section/div/div/main/article‘)
    #     for article in article_list:
    #         #xpath在进行数据提取时，返回的不再是字符串而是一个Selector对象，想要的数据被包含在了该对象的data参数中
    #         # title = article.xpath(‘./div[1]/h1/a/text()‘)[0].extract()
    #         title = article.xpath(‘./div[1]/h1/a/text()‘).extract_first()
    #         content = article.xpath(‘./div[2]//text()‘).extract()
    #         content = ‘‘.join(content)
    #         print(title,content)


    #==基于终端指令的持久化存储==
    def parse(self, response):
        all_data = []
        article_list = response.xpath(‘/html/body/section/div/div/main/article‘)
        for article in article_list:
            #xpath在进行数据提取时，返回的不再是字符串而是一个Selector对象，想要的数据被包含在了该对象的data参数中
            # title = article.xpath(‘./div[1]/h1/a/text()‘)[0].extract()
            title = article.xpath(‘./div[1]/h1/a/text()‘).extract_first()
            content = article.xpath(‘./div[2]//text()‘).extract()
            content = ‘‘.join(content)
            dic = {
                ‘title‘:title,
                ‘content‘:content
            }
            all_data.append(dic)
        return all_data #将解析到的数据进行了返回

• 伪属性
  • 图片懒加载：伪属性（自己定义的一个标签的属性，没有任何意义）
• js加密（js逆向），js混淆
  • 解密函数：js的解密函数
    • 对其进行逆向
  • js逆向：
    • 手动逆向
    • 自动逆向
      • PyExclJs：模拟执行js代码
        • nodeJs的环境安装
• scrapy
  • 1.环境的安装
    • Twisted：就是scrapy的异步机制
  • 2.创建工程：scrapy startproject proName
    • spiders：爬虫包，必须要存放一个或者多个爬虫文件
    • settings：配置文件
      • robots
      • UA
      • 指定日志等级：LOG_LEVEL = ‘ERROR‘
  • 3.cd proName
  • 4.创建爬虫文件：scrapy genspider spiderName www.xxx.com
    • 爬虫类：
      • name：爬虫文件的名称
      • start_url（列表）：放置的列表元素必须是待请求的url
        • 作用：可以将每一个列表元素进行请求（get）发送
      • parse(response):可以将scrapy请求到的数据进行解析
        • response：一个响应对象
  • 5.数据解析：
    • response.xpath()
      • 注意：
        • 在进行标签或属性的数据提取时，xpath返回的列表元素不再是字符串，而是Selector对象。
          • 需要调用extract()或者extract_first()将Selector中的字符串数据提取出来。
    • 持久化存储
      • 基于终端指令
        • 只可以将parse方法的返回值写入到指定后缀的文本文件中
        • scrapy crawl spiderName -o ./aaa.csv
      • 基于管道
    • 执行工程：
      • scrapy crawl spiderName

管道的持久化存储

• 基于管道的持久化存储的编码流程

  • 1.在爬虫文件中数据解析
  • 2.将解析到的数据封装到一个叫做Item类型的对象
  • 3.将item类型的对象提交给管道
  • 4.管道负责调用process_item的方法接收item，然后进行某种形式的持久化存储
  • 5.在配置文件中开启管道
  • 注意事项：
    • 什么情况下需要用到多个管道类
      • 一个管道类对应一种形式的持久化存储
    • process_item中的return item:
      • 可以将item提交给下一个即将被执行的管道类
    • 如果直接将一个字典写入到redis报错的话：
      • pip install redis==2.10.6

• 全栈数据的爬取

  • 手动请求的发送
    • yield scrapy.Request(url=new_url,callback=self.parse)
  • 总结：什么时候用yield
    • 1.向管道提交item的时候
    • 2.手动请求发送的时候
  • 如何发送post请求：
    • yield scrapy.FromRequest(url=new_url,callback=self.parse，formdata={})
  • 为什么start_urls列表可以进行get请求的发送：
    • 父类对start_requests的原始实现：
      def start_requests(self):
      for url in self.start_urls:
      yield scrapy.Request(url,callback=self.parse)

• 五大核心组件（对象）

  • 对scrapy的异步实现有一定的理解
  • 相关方法和对象实例化的调用流程
  • 组件的作用：
    引擎(Scrapy)
    用来处理整个系统的数据流处理, 触发事务(框架核心)
    调度器(Scheduler)
    用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL（抓取网页的网址或者说是链接）的优先队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
    下载器(Downloader)
    用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立在twisted这个高效的异步模型上的)
    爬虫(Spiders)
    爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体(Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
    项目管道(Pipeline)
    负责处理爬虫从网页中抽取的实体，主要的功能是持久化实体、验证实体的有效性、清除不需要的信息。当页面被爬虫解析后，将被发送到项目管道，并经过几个特定的次序处理数据。

• 如何适当提升scrapy爬取数据的效率
  增加并发：
  默认scrapy开启的并发线程为16个，可以适当进行增加。在settings配置文件中修改CONCURRENT_REQUESTS = 100值为100,并发设置成了为100。

  降低日志级别：
  在运行scrapy时，会有大量日志信息的输出，为了减少CPU的使用率。可以设置log输出信息为INFO或者ERROR即可。在配置文件中编写：LOG_LEVEL = ‘ERROR’

  禁止cookie：
  如果不是真的需要cookie，则在scrapy爬取数据时可以禁止cookie从而减少CPU的使用率，提升爬取效率。在配置文件中编写：COOKIES_ENABLED = False

  禁止重试：
  对失败的HTTP进行重新请求（重试）会减慢爬取速度，因此可以禁止重试。在配置文件中编写：RETRY_ENABLED = False

  减少下载超时：
  如果对一个非常慢的链接进行爬取，减少下载超时可以能让卡住的链接快速被放弃，从而提升效率。在配置文件中进行编写：DOWNLOAD_TIMEOUT = 10 超时时间为10s

• 请求传参

  • 作用：帮助scrapy实现深度爬取
    • 深度爬取：
      • 爬取的数据没有在同一张页面中
  • 需求：爬取名称和简介，https://www.4567tv.tv/frim/index1.html
  • 实现流程
    • 传参：
      • yield scrapy.Request(url,callback,meta),将meta这个字典传递给callback
    • 接收参数
      • response.meta

管道的持久化存储实例

• 爬虫文件

  # -*- coding: utf-8 -*-
  import scrapy
  from DuanziPro.items import DuanziproItem
  
  #管道机制对应的操作
  # class DuanziSpider(scrapy.Spider):
  #     name = ‘duanzi‘
  #     # allowed_domains = [‘www.xxx.com‘]
  #     start_urls = [‘http://duanziwang.com/category/%E7%BB%8F%E5%85%B8%E6%AE%B5%E5%AD%90/‘]
  #
  #     def parse(self, response):
  #         all_data = []
  #         article_list = response.xpath(‘/html/body/section/div/div/main/article‘)
  #         for article in article_list:
  #             # xpath在进行数据提取时，返回的不再是字符串而是一个Selector对象，想要的数据被包含在了该对象的data参数中
  #             # title = article.xpath(‘./div[1]/h1/a/text()‘)[0].extract()
  #             title = article.xpath(‘./div[1]/h1/a/text()‘).extract_first()
  #             content = article.xpath(‘./div[2]//text()‘).extract()
  #             content = ‘‘.join(content)
  #             #实例化一个item类型的对象，然后将解析到的一组数据存进去
  #             item = DuanziproItem()
  #             item[‘title‘] = title
  #             item[‘content‘] = content
  #
  #             yield item #将item提交给管道
  
  #全栈数据爬取对应的操作
  class DuanziSpider(scrapy.Spider):
      name = ‘duanzi‘
      # allowed_domains = [‘www.xxx.com‘]
      start_urls = [‘http://duanziwang.com/category/%E7%BB%8F%E5%85%B8%E6%AE%B5%E5%AD%90/‘]
      #通用的url模板
      url = ‘http://duanziwang.com/category/经典段子/%d/‘
      pageNum = 1
      # def start_requests(self):
      #     for url in self.start_urls:
      #         yield scrapy.Request(url,callback=self.parse)
      def parse(self, response):
          all_data = []
          article_list = response.xpath(‘/html/body/section/div/div/main/article‘)
          for article in article_list:
              # xpath在进行数据提取时，返回的不再是字符串而是一个Selector对象，想要的数据被包含在了该对象的data参数中
              # title = article.xpath(‘./div[1]/h1/a/text()‘)[0].extract()
              title = article.xpath(‘./div[1]/h1/a/text()‘).extract_first()
              content = article.xpath(‘./div[2]//text()‘).extract()
              content = ‘‘.join(content)
              # 实例化一个item类型的对象，然后将解析到的一组数据存进去
              item = DuanziproItem()
              item[‘title‘] = title
              item[‘content‘] = content
  
              yield item  # 将item提交给管道
          #编写手动请求的操作
          if self.pageNum < 5:
              self.pageNum += 1
              print(‘正在下载的页码是：‘,self.pageNum)
              new_url = format(self.url%self.pageNum)
              yield scrapy.Request(url=new_url,callback=self.parse)

• 构建管道items

  # -*- coding: utf-8 -*-
  
  # Define here the models for your scraped items
  #
  # See documentation in:
  # https://docs.scrapy.org/en/latest/topics/items.html
  
  import scrapy
  
  
  class DuanziproItem(scrapy.Item):
      # define the fields for your item here like:
      # name = scrapy.Field()
      title = scrapy.Field()
      content = scrapy.Field()

• 管道存储pipelines

  • # -*- coding: utf-8 -*-
      
      # Define your item pipelines here
      #
      # Don‘t forget to add your pipeline to the ITEM_PIPELINES setting
      # See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html
      
      #写入到文本文件中
      import pymysql
      from redis import Redis
      class DuanziproPipeline(object):
          fp = None
          def open_spider(self,spider):
              print(‘开始爬虫......‘)
              self.fp = open(‘./duanzi.txt‘,‘w‘,encoding=‘utf-8‘)
          #方法每被调用一次，参数item就是其接收到的一个item类型的对象
          def process_item(self, item, spider):
              # print(item)#item就是一个字典
              self.fp.write(item[‘title‘]+‘:‘+item[‘content‘]+‘\n‘)
              return item#可以将item提交给下一个即将被执行的管道类
          def close_spider(self,spider):
              self.fp.close()
              print(‘爬虫结束！！！‘)
      #将数据写入到mysql
      class MysqlPipeLine(object):
          conn = None
          cursor = None
          def open_spider(self,spider):
              self.conn = pymysql.Connect(host=‘127.0.0.1‘,port=3306,user=‘root‘,password=‘222‘,db=‘spider‘,charset=‘utf8‘)
              print(self.conn)
          def process_item(self,item,spider):
              sql = ‘insert into duanzi values ("%s","%s")‘%(item[‘title‘],item[‘content‘])
              self.cursor = self.conn.cursor()
              try:
                  self.cursor.execute(sql)
                  self.conn.commit()
              except Exception as e:
                  print(e)
                  self.conn.rollback()
              return item
          def close_spider(self,spider):
              self.cursor.close()
              self.conn.close()
      
      #将数据写入到redis
      class RedisPileLine(object):
          conn = None
          def open_spider(self,spider):
              self.conn = Redis(host=‘127.0.0.1‘,port=6379)
              print(self.conn)
          def process_item(self,item,spider):
              self.conn.lpush(‘duanziData‘,item)
              return item

请求传参实例

• 爬虫文件

  • # -*- coding: utf-8 -*-
      import scrapy
      from moviePro.items import MovieproItem
      #深度爬取
      # class MovieSpider(scrapy.Spider):
      #     name = ‘movie‘
      #     # allowed_domains = [‘www.xxx.com‘]
      #     start_urls = [‘https://www.4567tv.tv/index.php/vod/show/class/动作/id/1.html‘]
      #     url = ‘https://www.4567tv.tv/index.php/vod/show/class/动作/id/1/page/%d.html‘
      #     def parse(self, response):
      #         li_list = response.xpath(‘/html/body/div[1]/div/div/div/div[2]/ul/li‘)
      #         for li in li_list:
      #             title = li.xpath(‘.//div[@class="stui-vodlist__detail"]/h4/a/text()‘).extract_first()
      #             detail_url = ‘https://www.4567tv.tv‘+li.xpath(‘.//div[@class="stui-vodlist__detail"]/h4/a/@href‘).extract_first()
      #
      #             item = MovieproItem()
      #             item[‘title‘] = title
      #
      #             # print(title,detail_url)
      #             #对详情页的url进行手动请求发送
      #             #请求传参：
      #                 #参数meta是一个字典，字典会传递给callback
      #             yield scrapy.Request(detail_url,callback=self.parse_detail,meta={‘item‘:item})
      #     #自定义的另一个解析方法（必须要有response参数）
      #     def parse_detail(self,response):
      #         #接收传递过来的meta
      #         item = response.meta[‘item‘]
      #         desc = response.xpath(‘/html/body/div[1]/div/div/div/div[2]/p[5]/span[2]/text()‘).extract_first()
      #         item[‘desc‘] = desc
      #
      #         yield item
      
      
      #深度爬取+全栈爬取
      class MovieSpider(scrapy.Spider):
          name = ‘movie‘
          # allowed_domains = [‘www.xxx.com‘]
          start_urls = [‘https://www.4567tv.tv/index.php/vod/show/class/动作/id/1.html‘]
      
          url = ‘https://www.4567tv.tv/index.php/vod/show/class/动作/id/1/page/%d.html‘
          pageNum = 1
      
          def parse(self, response):
              li_list = response.xpath(‘/html/body/div[1]/div/div/div/div[2]/ul/li‘)
              for li in li_list:
                  title = li.xpath(‘.//div[@class="stui-vodlist__detail"]/h4/a/text()‘).extract_first()
                  detail_url = ‘https://www.4567tv.tv‘+li.xpath(‘.//div[@class="stui-vodlist__detail"]/h4/a/@href‘).extract_first()
      
                  item = MovieproItem()
                  item[‘title‘] = title
      
                  # print(title,detail_url)
                  #对详情页的url进行手动请求发送
                  #请求传参：
                      #参数meta是一个字典，字典会传递给callback
                  yield scrapy.Request(detail_url,callback=self.parse_detail,meta={‘item‘:item})
      
                  #全栈爬取
                  if self.pageNum < 4:
                      self.pageNum += 1
                      new_url = format(self.url%self.pageNum)
                      yield scrapy.Request(new_url,callback=self.parse)
          #自定义的另一个解析方法（必须要有response参数）
          def parse_detail(self,response):
              #接收传递过来的meta
              item = response.meta[‘item‘]
              desc = response.xpath(‘/html/body/div[1]/div/div/div/div[2]/p[5]/span[2]/text()‘).extract_first()
              item[‘desc‘] = desc
      
              yield item

• items

  • # -*- coding: utf-8 -*-
      
      # Define here the models for your scraped items
      #
      # See documentation in:
      # https://docs.scrapy.org/en/latest/topics/items.html
      
      import scrapy
      
      
      class MovieproItem(scrapy.Item):
          # define the fields for your item here like:
          title = scrapy.Field()
          desc = scrapy.Field()

• pipelines

  • # -*- coding: utf-8 -*-
      
      # Define your item pipelines here
      #
      # Don‘t forget to add your pipeline to the ITEM_PIPELINES setting
      # See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html
      
      
      class MovieproPipeline(object):
          def process_item(self, item, spider):
              print(item)
              return item

• robots

• UA伪装

• 动态变化的请求参数

• 验证码

• cookie

• 代理

• 动态加载的数据

• js加密

• js混淆

• 图片懒加载