码迷,mamicode.com
首页 > 移动开发 > 详细

python爬虫入门 之 移动端数据的爬取

时间:2019-09-10 16:16:17      阅读:190      评论:0      收藏:0      [点我收藏+]

标签:分布   抓包工具   形式   tor   aik   过滤   you   property   print   

第七章 移动端数据的爬取

  • 基于某一款抓包工具 : fiddler ,青花瓷 ,miteproxy

7.1 fiddler 基本配置

7.1.1fiddler简介和安装

  • 什么是Fiddler?

    • Fiddler是位于客户端和服务器端的HTTP代理,也是目前最常用的http抓包工具之一 。 它能够记录客户端和服务器之间的所有 HTTP请求,可以针对特定的HTTP请求,分析请求数据、设置断点、调试web应用、修改请求的数据,甚至可以修改服务器返回的数据,功能非常强大,是web调试的利器。

  • Fiddler安装

7.1.2手机APP抓包设置

  • Fiddler设置打开Fiddler软件,打开工具的设置。(Fiddler软件菜单栏:Tools->Options)在HTTPS中设置如下:技术图片

  • 在Connections中设置如下

    • 这里使用默认8888端口,当然也可以自己更改,但是注意不要与已经使用的端口冲突:Allow remote computers to connect:允许别的机器把请求发送到fiddler上来

    技术图片

  • 安全证书下载

    • 在电脑浏览器中输入地址:http://localhost:8888/,点击FiddlerRoot certificate,下载安全证书:技术图片

  • 安全证书安装

    • 证书是需要在手机上进行安装的,这样在电脑Fiddler软件抓包的时候,手机使用电脑的网卡上网才不会报错。

  • Android手机安装:

    • 把证书放入手机的内置或外置存储卡上,然后通过手机的"系统安全-》从存储设备安装"菜单安装证书。然后找到拷贝的FiddlerRoot.cer进行安装即可。安装好之后,可以在信任的凭证中找到我们已经安装好的安全证书。技术图片

  • 苹果手机安装:

    • 保证手机网络和fiddler所在机器网络是同一个网段下的在safari中访问http://fiddle机器ip:fiddler端口,进行证书下载。然后进行安装证书操作。在手机中的设置-》通用-》关于本机-》证书信任设置-》开启fiddler证书信任

  • 局域网设置 想要使用Fiddler进行手机抓包,首先要确保手机和电脑的网络在一个内网中,可以使用让电脑和手机都连接同一个路由器。当然,也可以让电脑开放WIFI热点,手机连入。这里,我使用的方法是,让手机和电脑同时连入一个路由器中。最后,让手机使用电脑的代理IP进行上网。 在手机上,点击连接的WIFI进行网络修改,添加代理。进行手动设置,ip和端口号都是fiddler机器的ip和fiddler上设置的端口号。

  • Fiddler手机抓包测试

    • 上述步骤都设置完成之后,用手机浏览器打开百度首页,我们就可以顺利抓包了

7.1.3移动端数据的捕获流程

  • tools --> options --> connection -->allow remote

  • http: fiddler所在pc机的ip :8888/ 访问到一张提供了证书下载功能的界面

  • fiddler所在机器和手机在同一网段下 :在手机上浏览器中访问 http: fiddler所在pc机的ip :8888 获取子页面进行证书的下载和安装(证书信任的操作)

  • 配置你手机的代理 :将手机的代理配置成 fiddler所对应的pc机的ip和手机自己的端口

  • 就可以让fiddler捕获手机发起的http和https的请求

7.2 scrapy ,pyspider

#总结:
?
#爬虫文件中的属性和方法
name :爬虫文件唯一标识
start_url:该列表中的url会被自动的进行请求发送
#自动请求发送的过程:
def start_requests(self):
       for url in self.start_urls:
           yield scrapy.Request(url,callback=self.parse)
?
#数据解析:
scrapy中封装的xpath进行数据解析
   
#scrapy中的xpath 和 etree中的xpath的区别
scrapy的xpath进行数据解析后返回的列表元素为Selector对象,extract或extract_first这两个方法将Selector对象中对应的数据取出
?

 

7.2.1Scrapy简介

  • 什么是框架?如何学习

    • 框架就是一个集成各种功能且具有很强通用性(可以被应用在各种不同的需求中)的一个项目模板

    • 我们只需要学习框架中封装好的相关功能即可

  • scrapy 集成的功能

    • 高性能的数据解析操作 ,持久化存储,高性能的数据下载操作......

  • 环境的安装(windows)

7.2.2 scrapy的基本使用

  • 创建一个工程 :scrapy startproject firstBlood

    • 项目结构:

      project_name/
        scrapy.cfg:            #项目的主配置信息。(真正爬虫相关的配置信息在settings.py文件中)
        project_name/
            __init__.py  
            items.py            #设置数据存储模板,用于结构化数据,如:Django的Model
            pipelines.py        #数据持久化处理
            settings.py         #配置文件,如:递归的层数、并发数,延迟下载等
            spiders/            #爬虫目录,如:创建文件,编写爬虫解析规则
                __init__.py
  • 创建爬虫应用程序:(必须在spider这个目录下创建一个爬虫文件)

    • cd proName

    • scrapy genspider spiderName www.xx.com

  • 编写爬虫文件:在步骤2执行完毕后,会在项目的spiders中生成一个应用名的py爬虫文件

    import scrapy
    
    class FirstSpider(scrapy.Spider):
        #爬虫文件的名称:爬虫文件的唯一标识(在spiders子目录下是可以创建多个爬虫文件)
        name = ‘first‘
        #允许的域名
        # allowed_domains = [‘www.baidu.com‘]
        #起始的url列表:列表中存放的url会被scrapy自动的进行请求发送
        start_urls = [‘https://www.baidu.com/‘,‘https://www.sogou.com/‘]
        #用作于数据解析:将start_urls列表中对应的url请求成功后的响应数据进行解析
        def parse(self, response):
            print(response.text) #获取字符串类型的响应内容
            print(response.body)#获取字节类型的相应内容
    
  • 设置修改settings.py配置文件相关配置

    # settings.py 文件中
    	#不遵从robots协议
        #进行UA伪装
        #进行日志等级设定: LOG_LEVEL = False
    

    setting.py中 ----- 基于终端指令的持久化存储操作

    BOT_NAME = ‘firstBlood‘
    
    SPIDER_MODULES = [‘firstBlood.spiders‘]
    NEWSPIDER_MODULE = ‘firstBlood.spiders‘
    
    
    # Crawl responsibly by identifying yourself (and your website) on the user-agent
    USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘       #进行ua伪装
    # Obey robots.txt rules
    ROBOTSTXT_OBEY = False    #不遵从robotstx协议
    LOG_LEVEL = ‘ERROR‘       #输出错误类型的日志
    

    setting.py ------------- 基于管道的持久化存储

    BOT_NAME = ‘qiubaiPro‘
    USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘
    
    SPIDER_MODULES = [‘qiubaiPro.spiders‘]
    NEWSPIDER_MODULE = ‘qiubaiPro.spiders‘
    
    
    ITEM_PIPELINES = {
       ‘qiubaiPro.pipelines.QiubaiproPipeline‘: 300, #300表示的是优先级(数值越小优先级越大)
    }
    
  • 执行爬虫程序:scripy crawl spiderName

    • 不输出日志(错误信息会在日志中输出,不要使用) scripy crawl spiderName --nolog

7.2.3scrapy框架持久化存储

#持久化存储
	#基于终端指令
    	特性 : 只能将 parse 方法的返回值存储到本地的磁盘文件中
        指令 : scripy crawl spiderName -o filepath
    #基于管道
    	#实现流程
        1.数据解析
        2.在item类中定义相关属性
        3.将解析的数据封装到一个 item 对象中(item文件中对应类的对象)
        4.向管道提交item
        5.在管道文件中的 process_item 方法中接收 item 进行持久化存储
        6.在配置文件中开启管道
    
    #管道中需注意细节:
		1.配置文件中开启的管道是一个字典,字典中的键值表示的就是某一个管道
		2.在管道对应的源文件中其实可以定义多个管道类,一种形式的持久化存储
		3.在process_item方法中的 return item 表示的是提交给下一个即将被执行的管道类
		4.爬虫文件中yield item 只可以将item传递给第一个被执行的(优先级最高的)管道
	
    #将同一份数据持久化存储到不同平台中:
    	#分析
        1.管道文件中的一个管道内负责数据的一种形式的持久化存储

setting.py中 ----- 基于终端指令的持久化存储操作

BOT_NAME = ‘firstBlood‘

SPIDER_MODULES = [‘firstBlood.spiders‘]
NEWSPIDER_MODULE = ‘firstBlood.spiders‘


# Crawl responsibly by identifying yourself (and your website) on the user-agent
USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘       #进行ua伪装
# Obey robots.txt rules
ROBOTSTXT_OBEY = False    #不遵从robotstx协议
LOG_LEVEL = ‘ERROR‘       #输出错误类型的日志

setting.py ------------- 基于管道的持久化存储

BOT_NAME = ‘qiubaiPro‘
USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘

SPIDER_MODULES = [‘qiubaiPro.spiders‘]
NEWSPIDER_MODULE = ‘qiubaiPro.spiders‘


ITEM_PIPELINES = {
   ‘qiubaiPro.pipelines.QiubaiproPipeline‘: 300, #300表示的是优先级(数值越小优先级越大)
}

糗事百科

qiubai.py

import scrapy
from qiubaiPro.items import QiubaiproItem

class QiubaiSpider(scrapy.Spider):
    name = ‘qiubai‘
    # allowed_domains = [‘www.xxx.com‘]
    start_urls = [‘https://www.qiushibaike.com/text/‘]
    
    #基于终端指令的持久化存储操作
    # def parse(self, response):
    #     div_list = response.xpath(‘//*[@id="content-left"]/div‘)
    #     all_data = []
    #     for div in div_list:
    #         #scrapy中的xpath返回的列表的列表元素一定是Selector对象,我们最终想要的解析的
    #         #数据一定是存储在该对象中
    #         #extract()将Selector对象中data参数的值取出
    #         # author = div.xpath(‘./div[1]/a[2]/h2/text()‘)[0].extract()
    #         author = div.xpath(‘./div[1]/a[2]/h2/text()‘).extract_first()
    #         #列表直接调用extract表示的是将extract作用到每一个列表元素中
    #         content = div.xpath(‘./a[1]/div/span//text()‘).extract()
    #         content = ‘‘.join(content)
    #         dic = {
    #             ‘author‘:author,
    #             ‘content‘:content
    #         }
    #         all_data.append(dic)
    #     return all_data
    
   
    #基于管道的持久化存储
    def parse(self, response):
        div_list = response.xpath(‘//*[@id="content-left"]/div‘)
        all_data = []
        for div in div_list:
            #scrapy中的xpath返回的列表的列表元素一定是Selector对象,我们最终想要的解析的
            #数据一定是存储在该对象中
            #extract()将Selector对象中data参数的值取出
            # author = div.xpath(‘./div[1]/a[2]/h2/text()‘)[0].extract()
            author = div.xpath(‘./div[1]/a[2]/h2/text()‘).extract_first()
            #列表直接调用extract表示的是将extract作用到每一个列表元素中
            content = div.xpath(‘./a[1]/div/span//text()‘).extract()
            content = ‘‘.join(content)

            #将解析的数据存储到item对象
            item = QiubaiproItem()
            item[‘author‘] = author
            item[‘content‘] = content

            #将item提交给管道
            yield item #item一定是提交给了优先级最高的管道类

itims.py

import scrapy

class QiubaiproItem(scrapy.Item):
    # define the fields for your item here like:
    author = scrapy.Field() #Field可以将其理解成是一个万能的数据类型
    content = scrapy.Field()

pipelines.py 管道文件

import pymysql
from redis import Redis
class QiubaiproPipeline(object):
    fp = None
    def open_spider(self,spider):
        print(‘开始爬虫......‘)
        self.fp = open(‘qiushibaike.txt‘,‘w‘,encoding=‘utf-8‘)

    #使用来接收爬虫文件提交过来的item,然后将其进行任意形式的持久化存储
    #参数item:就是接收到的item对象
    #该方法每接收一个item就会调用一次
    def process_item(self, item, spider):
        author = item[‘author‘]
        content= item[‘content‘]

        self.fp.write(author+‘:‘+content+‘\n‘)
        return item #item是返回给了下一个即将被执行的管道类

    def close_spider(self,spider):
        print(‘结束爬虫!‘)
        self.fp.close()

        
#负责将数据存储到mysql
class MysqlPL(object):
    conn = None
    cursor = None
    def open_spider(self,spider):
        self.conn = pymysql.Connect(host=‘127.0.0.1‘,port=3306,user=‘root‘,password=‘123‘,db=‘spider‘,charset=‘utf8‘)
        print(self.conn)
    def process_item(self,item,spider):
        author = item[‘author‘]
        content = item[‘content‘]

        sql = ‘insert into qiubai values ("%s","%s")‘%(author,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 RedisPL(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(‘all_data‘,item)     # name  value
        #注意:如果将字典写入redis报错:pip install -U redis==2.10.6

7.2.4scrapy框架之递归解析和post请求

递归解析(手动请求发送)

  • 使用场景 :爬取多个页码对应的页面源码数据

  • yield scrapy.Request(url,callback)

import scrapy
from qiubaiPro.items import QiubaiproItem

class QiubaiSpider(scrapy.Spider):
    name = ‘qiubai‘
    # allowed_domains = [‘www.xxx.com‘]
    start_urls = [‘https://www.qiushibaike.com/text/‘]

    #将多个页码对应的页面数据进行爬取和解析的操作
    url = ‘https://www.qiushibaike.com/text/page/%d/‘#通用的url模板
    pageNum = 1
    #parse第一次调用表示的是用来解析第一页对应页面中的段子内容和作者
    def parse(self, response):
        div_list = response.xpath(‘//*[@id="content-left"]/div‘)
        all_data = []
        for div in div_list:
            # scrapy中的xpath返回的列表的列表元素一定是Selector对象,我们最终想要的解析的
            # 数据一定是存储在该对象中
            # extract()将Selector对象中data参数的值取出
            # author = div.xpath(‘./div[1]/a[2]/h2/text()‘)[0].extract()
            author = div.xpath(‘./div[1]/a[2]/h2/text()‘).extract_first()
            # 列表直接调用extract表示的是将extract作用到每一个列表元素中
            content = div.xpath(‘./a[1]/div/span//text()‘).extract()
            content = ‘‘.join(content)

            # 将解析的数据存储到item对象
            item = QiubaiproItem()
            item[‘author‘] = author
            item[‘content‘] = content

            # 将item提交给管道
            yield item  # item一定是提交给了优先级最高的管道类

        if self.pageNum <= 5:
            self.pageNum += 1
            new_url = format(self.url%self.pageNum)
            #手动请求(get)的发送
            yield scrapy.Request(new_url,callback=self.parse)

post请求发送

  • 问题:在之前代码中,我们从来没有手动的对start_urls列表中存储的起始url进行过请求的发送,但是起始url的确是进行了请求的发送,那这是如何实现的呢?

    • 解答:其实是因为爬虫文件中的爬虫类继承到了Spider父类中的start_requests(self)这个方法,该方法就可以对start_urls列表中的url发起请求:

        def start_requests(self):
              for u in self.start_urls:
                 yield scrapy.Request(url=u,callback=self.parse)
      
  • 【注意】该方法默认的实现,是对起始的url发起get请求,如果想发起post请求,则需要子类重写该方法。

    • 方法: 重写start_requests方法,让其发起post请求:

    def start_requests(self):
            #请求的url
            post_url = ‘http://fanyi.baidu.com/sug‘
            # post请求参数
            formdata = {
                ‘kw‘: ‘wolf‘,
            }
            # 发送post请求
            yield scrapy.FormRequest(url=post_url, formdata=formdata, callback=self.parse)
    

scrapy五大核心组件

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

    技术图片

    技术图片

    #步骤
    1.spider中的url被封装成请求对象交给引擎(每一个url对应一个请求对象);
    2.引擎拿到请求对象之后, 将其全部交给调度器;
    3.调度器拿到所有请求对象后, 通过内部的过滤器过滤掉重复的url, 最后将去重后的所有url对应的请求对象压入到队列中, 随后调度器调度出其中一个请求对象, 并将其交给引擎;
    4.引擎将调度器调度出的请求对象交给下载器;
    5.下载器拿到该请求对象去互联网中下载数据;
    6.数据下载成功后会被封装到response中, 随后response会被交给下载器;
    7.下载器将response交给引擎;
    8.引擎将response交给spiders;
    9.spiders拿到response后调用回调方法进行数据解析, 解析成功后产生item, 随后spiders将item交给引擎;
    10.引擎将item交给管道, 管道拿到item后进行数据的持久化存储.
    

7.3基于scrapy进行图片数据的爬取

  • 示例 :校花网图片的爬取

    链接地址 :http://www.521609.com/daxuemeinv/list81.html

  • 项目的创建

    • scrapy startproject imgPro

    • cd imgPro

    • scrapy genspider img www.xxx.com

      技术图片

  • 如何基于scrapy进行图片的爬取

    1.在爬虫文件中只需要解析出图片地址,然后将图片地址提交给管道
    2.配置文件中添加  IMAGES_STORE = ‘./imasLib‘
    1.在管道文件中进行管道类的制定:
        from scrapy.pipelines.images import ImagesPipeline
        将管道的父类修改成 ImagesPipeline
        重写父类的三个方法
    
  • 代码:

    img.py

    import scrapy
    from imgPro.items import ImgproItem
    
    class ImgSpider(scrapy.Spider):
        name = ‘img‘
        # allowed_domains = [‘www.x.com‘]
        start_urls = [‘http://www.521609.com/daxuemeinv/‘]
        url = ‘http://www.521609.com/daxuemeinv/list8%d.html‘
        pageNum = 1
        def parse(self, response):
            li_list = response.xpath(‘//*[@id="content"]/div[2]/div[2]/ul/li‘)
            for li in li_list:
                img_src = ‘http://www.521609.com‘ + li.xpath(‘./a[1]/img/@src‘).extract_first()
                item = ImgproItem()
                item[‘src‘] = img_src
    
                yield item
    
            if self.pageNum < 4:
                self.pageNum += 1
                new_url = format(self.url%self.pageNum)
                yield scrapy.Request(new_url,callback=self.parse)
    

    setting.py

    ##不遵从robotstx协议
    ROBOTSTXT_OBEY = False
    
    #输出错误类型的日志
    LOG_LEVEL = ‘ERROR‘
    # LOG_FILE = ‘./log.txt‘
    
    #图片存储地址
    IMAGES_STORE = ‘./imasLib‘
    
    ITEM_PIPELINES = {
       ‘imgPro.pipelines.ImgproPipeline‘: 300,
    }
    

    pipelines.py

    import scrapy
    from scrapy.pipelines.images import ImagesPipeline
    
    class ImgproPipeline(ImagesPipeline):
    
        #对某一个媒体资源进行请求发送
        # item 就是接收到的spider提交的数据
        def get_media_requests(self, item, info):
            yield scrapy.Request(item[‘src‘])
    
        #指定媒体数据存储的名称
        def file_path(self, request, response=None, info=None):
            #返回原始图片名称
            name = request.url.split(‘/‘)[-1]
            print("正在下载:",name)
            return name
    
        #将 item 传递给下一个即将被执行的管道类
        def item_completed(self, results, item, info):
            return item
    

    items.py

    import scrapy
    
    class ImgproItem(scrapy.Item):
        # define the fields for your item here like:
        src = scrapy.Field()
    
    

如何提升scrapy爬取数据的效率

只需要将如下五个步骤配置在配置文件中即可:

#增加并发
	默认scrapy开启的并发线程为32个,可以适当进行增加。在settings配置文件中修改CONCURRENT_REQUESTS = 100值为100,并发设置成了为100。
    
#降低日志级别:
	在运行scrapy时,会有大量日志信息的输出,为了减少CPU的使用率。可以设置log输出信息为INFO或者ERROR即可。在配置文件中编写:LOG_LEVEL = ‘INFO’

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

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

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

7.4请求传参

  • 实现深度爬取:爬取多个层级对应的页面数据

  • 使用场景:爬取的数据没有在同一张页面中

  • 在手动请求的时候传递item:yield scrapy.Request(url,callback,meta={‘item‘:item})

    • 将meta这个字典传递给callback

    • 在callback中接收meta:item = response.meta[‘item‘]

  • 代码:

    movie.py

    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/5.html‘]
    
        url = ‘https://www.4567tv.tv/index.php/vod/show/class/动作/id/5/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[1]/a/@title‘).extract_first()
                detail_url = "https://www.4567tv.tv" + li.xpath(‘./div[1]/a/@href‘).extract_first()
    
                item = MovieproItem()
                item[‘title‘] = title
                # meta参数是一个字典,该参数可以传递给callback指定的回调函数,
                yield scrapy.Request(detail_url,callback=self.parse_detail,meta={‘item‘:item})
    
            if self.pageNum < 5:
                self.pageNum += 1
                new_url = format(self.url%self.pageNum)
                yield scrapy.Request(new_url,callback=self.parse)
    
    
        def parse_detail(self,response):
            #接收参数 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
    

    setting.py

    BOT_NAME = ‘moviePro‘
    
    SPIDER_MODULES = [‘moviePro.spiders‘]
    NEWSPIDER_MODULE = ‘moviePro.spiders‘
    
    # UA伪装
    USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘
    
    # Obey robots.txt rules
    ROBOTSTXT_OBEY = False
    #输出错误类型的日志
    LOG_LEVEL = ‘ERROR‘
    
    
    ITEM_PIPELINES = {
       ‘moviePro.pipelines.MovieproPipeline‘: 300,
    }
    

    items.py

    import scrapy
    
    class MovieproItem(scrapy.Item):
        # define the fields for your item here like:
        title = scrapy.Field()
        desc = scrapy.Field()
    

    pipelines.py

    class MovieproPipeline(object):
        def process_item(self, item, spider):
            print(item)
            return item
    

7.5scrapy中的中间件的应用

1.请求载体身份标识(可用)

user_agent_list = [
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1",
        "Mozilla/5.0 (X11; CrOS i686 2268.111.0) AppleWebKit/536.11 "
        "(KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1092.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1090.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/19.77.34.5 Safari/537.1",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.9 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.0 Safari/536.3",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24"
]

3.代理池(不可用)

PROXY_http = [
    ‘153.180.102.104:80‘,
    ‘195.208.131.189:56055‘,
]
PROXY_https = [
    ‘120.83.49.90:9000‘,
    ‘95.189.112.214:35508‘,
]

3.爬虫中间件

4.下载中间件

  • 作用 :批量拦截请求和响应

拦截请求

  • UA伪装 :将所有的请求尽可能多的设定成不同的请求载体身份标识

  • 代理操作

from scrapy import signals
import random
user_agent_list = [
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1",
        "Mozilla/5.0 (X11; CrOS i686 2268.111.0) AppleWebKit/536.11 "
        "(KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1092.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1090.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/19.77.34.5 Safari/537.1",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.9 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.0 Safari/536.3",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24"
]

PROXY_http = [
    ‘153.180.102.104:80‘,
    ‘195.208.131.189:56055‘,
]
PROXY_https = [
    ‘120.83.49.90:9000‘,
    ‘95.189.112.214:35508‘,
]

# 下载中间件
class MovieproDownloaderMiddleware(object):

    # 拦截正常的请求,参数 request 就是拦截到请求对象
    def process_request(self, request, spider):
        print("i am process_request")
        #实现:将拦截到的请求尽可能多的设定成不同的请求载体身份标识
        request.headers[‘USER_AGENT‘] = random.choice(user_agent_list)

        if request.url.split(":")[0] == "http":
            request.meta[‘proxy‘] = ‘http://‘ + random.choice(PROXY_http)
        else:
            request.meta[‘proxy‘] = ‘https://‘ + random.choice(PROXY_https)
        return None


    # 拦截响应,参数 request 就是拦截到响应
    def process_response(self, request, response, spider):
        print("i am process_response")
        return response

    # 拦截发生异常的请求
    def process_exception(self, request, exception, spider):
        print("i am process_exception")
        #拦截到异常的请求,然后对其进行修正,然后重新进行请求发送
        #代理操作
        if request.url.split(":")[0] == "http":
            request.meta[‘proxy‘] = ‘http://‘ + random.choice(PROXY_http)
        else:
            request.meta[‘proxy‘] = ‘https://‘ + random.choice(PROXY_https)
        #将修正后的请求进行重新发送
        return request

拦截响应

  • 篡改响应数据或直接替换响应对象

  • 需求 : 爬取网易新闻 国内,国际,军事,航空,无人机这五个板块下对应的新闻标题和内容

    #分析:
    1.每一个板块对应的新闻数据是动态加载出来的
    
    # selenium在scrapy中的应用:
    	实例化浏览器对象:卸载爬虫类的构造方法中
    

    wangyi.py

    import scrapy
    from selenium import webdriver
    from wangyiPro.items import WangyiproItem
    
    class WangyiSpider(scrapy.Spider):
        name = ‘wangyi‘
        # allowed_domains = [‘www.xxx.com‘]
        start_urls = [‘https://news.163.com‘]
    
        five_model_urls = []
        #实例化一个浏览器对象
        bro = webdriver.Chrome(executable_path=r‘E:\飞秋\爬虫+数据\tools\chromedriver.exe‘)
        #用来解析五个板块对应的url,然后对齐进行手动请求发送
        def parse(self, response):
            model_index = [3,4,6,7,8]
            li_list = response.xpath(‘//*[@id="index2016_wrap"]/div[1]/div[2]/div[2]/div[2]/div[2]/div/ul/li‘)
    
            for index in model_index:
                li = li_list[index]
                #获取五个板块对应的url
                model_url = li.xpath(‘./a/@href‘).extract_first()
                self.five_model_urls.append(model_url)
                #对每个板块的url进行手动请求发送
                yield scrapy.Request(model_url,callback=self.parse_model)
    
        #用作与解析每个板块中的新闻标题和新闻详情页的url
        #问题:response(不满足需求的response)没有包含每一个板块中动态加载的新闻数据
        def parse_model(self,response):
            div_list = response.xpath(‘/html/body/div/div[3]/div[4]/div[1]/div/div/ul/li/div/div‘)
            for div in div_list:
                title = div.xpath(‘./div/div[1]/h3/a/text()‘).extract_first()
                detail_url = div.xpath(‘./div/div[1]/h3/a/@href‘).extract_first()
                item = WangyiproItem()
                item[‘title‘] = title
                #对详情页发起请求解析出新闻内容
                yield scrapy.Request(detail_url,callback=self.prase_new_detail,meta={‘item‘:item})
    
        def prase_new_detail(self,response):
            item = response.meta[‘item‘]
            content = response.xpath(‘//*[@id="endText"]//text()‘).extract()
            content = ‘‘.join(content)
            item[‘content‘] = content
            yield  item
    
        #最后执行
        def closed(self,spider):
            self.bro.quit()
    

    items.py

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

    middlewares.py

    from scrapy import signals
    from scrapy.http import HtmlResponse
    from time import sleep
    
    class WangyiproDownloaderMiddleware(object):
    
        def process_request(self, request, spider):
    
            return None
    
        # spider 就是爬虫文件中爬虫类实例化的对象
        def process_response(self, request, response, spider):
            #进行所有响应对象的拦截
            # 1.将所有响应对象中那五个不满足需求的响应对象找出
                #每个响应对象对应唯一一个请求对象
                #如果我们定位到五个响应对象的请求对象后,就可以通过该请求对象定位到指定的响应对象
                #可以通过五个板块的 url 定位请求对象
                    #总结: url ==> request ==> response
            # 2.将找出的五个不满足需求的响应对象进行修正(替换)
    
            #  spider.five_model_urls :五个板块对应的url
            bro = spider.bro
            if request.url in spider.five_model_urls:
                bro.get(request.url)
                sleep(1)
                #包含了动态加载的新闻数据
                page_text = bro.page_source
                #如果if条件成立,则该response就是五个板块对应的响应对象
                new_response = HtmlResponse(url=request.url,body=page_text,encoding=‘utf-8‘,request=request)
                return new_response
            return response
    
        def process_exception(self, request, exception, spider):
            pass
    

    pipelines.py

    class WangyiproPipeline(object):
        def process_item(self, item, spider):
            print(item)
            return item
    

    setting.py

    BOT_NAME = ‘wangyiPro‘
    
    SPIDER_MODULES = [‘wangyiPro.spiders‘]
    NEWSPIDER_MODULE = ‘wangyiPro.spiders‘
    
    # UA伪装
    USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘
    
    ROBOTSTXT_OBEY = False
    LOG_LEVEL = ‘ERROR‘
    
    DOWNLOADER_MIDDLEWARES = {
       ‘wangyiPro.middlewares.WangyiproDownloaderMiddleware‘: 543,
    }
    
    ITEM_PIPELINES = {
       ‘wangyiPro.pipelines.WangyiproPpeline‘: 300,
    }
    

7.6.基于CrawSpider的全站数据爬取

  • CrawSpider简介

    • CrawSpider就是爬虫类中 Spider的一个子类

    • 除了继承到Spider的特性和功能外,还派生除了其自己独有的更加强大的特性和功能。其中最显著的功能就是”LinkExtractors链接提取器“。Spider是所有爬虫的基类,其设计原则只是为了爬取start_url列表中网页,而从爬取到的网页中提取出的url进行继续的爬取工作使用CrawlSpider更合适。

  • 使用流程

    1.创建一个基于CrawSpider的爬虫文件 : 
        scrapy startproject sunPro
        cd sunPro
        scrapy genspider -t crawl spiderName www.xxx.com
    2.构造链接提取器和规则解析器
    	链接提取器
    		作用:可根据指定的规则进行指定链接的提取
             提取规则:allow = ‘正则表达式‘
    	规则解析器
    		作用:获取链接提取器提取到的链接,然后进行请求发送,根据指定规则对请求到的页面源码数据进行数据解析
    		follow = ‘True‘ :将链接提取器 继续作用到 链接提取器所提取到的页码链接所对应的页面中 
    

7.6.1 基于CrawSpider的基本使用

数据链接地址 :http://wz.sun0769.com/index.php/question/questionType?type=4&page=

sun.py

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule

#未实现深度爬取:爬取的只是每个页面对应的数据
class SunSpider(CrawlSpider):
    name = ‘sun‘
    # allowed_domains = [‘www.xxx.com‘]
    start_urls = [‘http://wz.sun0769.com/index.php/question/questionType?type=4&page=‘]
    #链接提取器  type=4&page=\d+
    link = LinkExtractor(allow=r‘type=4&page=\d+‘)

    rules = (
        #实例化一个Rule(规则解析器)的对象
        Rule(link, callback=‘parse_item‘, follow=True),
    )

    def parse_item(self, response):
        tr_list = response.xpath(‘//*[@id="morelist"]/div/table[2]//tr/td/table//tr‘)
        for tr in tr_list:
            title = tr.xpath(‘./td[2]/a[2]/@title‘).extract_first()
            status = tr.xpath(‘./td[3]/span/text()‘).extract_first()
            print(title,status)

setting.py

BOT_NAME = ‘sunPro‘

SPIDER_MODULES = [‘sunPro.spiders‘]
NEWSPIDER_MODULE = ‘sunPro.spiders‘

# UA伪装
USER_AGENT = ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36‘

ROBOTSTXT_OBEY = False
LOG_LEVEL = ‘ERROR‘

技术图片

7.6.2 基于CrawSpider的深度爬取

sun.py

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from sunPro.items import SunproItem,SunproItem_detail

class SunSpider(CrawlSpider):
    name = ‘sun‘
    # allowed_domains = [‘www.xxx.com‘]
    start_urls = [‘http://wz.sun0769.com/index.php/question/questionType?type=4&page=‘]
    #链接提取器
    link = LinkExtractor(allow=r‘type=4&page=\d+‘)

    #详情页url  question/201909/426989.shtml
    link_detail = LinkExtractor(allow=r‘question/\d+/\d+\.shtml‘)

    rules = (
        #实例化一个Rule(规则解析器)的对象
        Rule(link, callback=‘parse_item‘, follow=True),
        Rule(link_detail, callback=‘parse_datail‘),
    )

    def parse_item(self, response):
        tr_list = response.xpath(‘//*[@id="morelist"]/div/table[2]//tr/td/table//tr‘)
        for tr in tr_list:
            title = tr.xpath(‘./td[2]/a[2]/@title‘).extract_first()
            status = tr.xpath(‘./td[3]/span/text()‘).extract_first()
            num = tr.xpath(‘./td[1]/text()‘).extract_first()
            item = SunproItem()
            item[‘title‘] = title
            item[‘status‘] = status
            item[‘num‘] = num
            if num:
                yield item

    def parse_datail(self,response):
        content = response.xpath(‘/html/body/div[9]/table[2]/tbody/tr[1]//text()‘).extract()
        content = ‘‘.join(content)
        num = response.xpath(‘/html/body/div[9]/table[1]/tbody/tr/td[2]/span[2]/text()‘).extract_first()
        if num:
            num = num.split(‘:‘)[-1]
            item = SunproItem_detail()
            item[‘content‘] = content
            item[‘num‘] = num
            yield item

pipelines.py

class SunproPipeline(object):
    def process_item(self, item, spider):

        if item.__class__.__name__ == "SunproItem_detail":
            content = item[‘content‘]
            num = item[‘num‘]
            print(content,num)
        else:
            title = item[‘title‘]
            status = item[‘status‘]
            num = item[‘num‘]
            print(title,status,num)

items.py

class SunproItem(scrapy.Item):
    title = scrapy.Field()
    status = scrapy.Field()
    num = scrapy.Field()

class SunproItem_detail(scrapy.Item):
    content = scrapy.Field()
    num = scrapy.Field()

7.7.分布式

7.7.1基本概念

  • 什么是分布式爬虫?

    • 基于多台电脑组建一个分布式机群,然后让机群中的每一台电脑执行同一组程序,然后让它们对同一个网站的数据进行分布爬取

  • 为什么要用分布式爬虫?

    • 提升爬取数据的效率

  • 如何实现分布式爬虫?

    • 基于scrapy + redis 的形式实现分布式

      • scrapy 结合着 scrapy-redis组件实现分布式

  • 原生的scrapy无法实现分布式原因?

    • 调度器无法被分布式群共享

    • 管道无法被共享

  • scrapy-redis组件的作用

    • 提供可以被共享的调度器和管道

  • 环境安装:

    • pip insatll redis

    • pip install scrapy-redis

7.7.2分布式流程

#1.创建一个基于CrawSpider的爬虫文件 : 
    scrapy startproject sunPro
    cd sunPro
    scrapy genspider -t crawl spiderName www.xxx.com
#2.修改当前的爬虫文件
	1.导包 : from scrapy_redis.spiders import RedisCrawlSpider
   	2.将当前爬虫类的父类修改成RedisCrawlSpider
    3.将start_urls替换成redis_key = ‘xxx‘  #表示的是可被共享调度器中队列的名称
	4.编写爬虫类爬取数据的操作
#3.对setting进行操作 
	#指定管道
		开启可被共享的管道 :
			ITEM_PIPELINES = {
                ‘scrapy_redis.pipelines.RedisPipeline‘: 400
				}
	#指定可被共享的调度器
    
# 增加了一个去重容器类的配置, 作用使用Redis的set集合来存储请求的指纹数据, 从而实现请求去重的持久化
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用scrapy-redis组件自己的调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 配置调度器是否要持久化, 也就是当爬虫结束了, 要不要清空Redis中请求队列和去重指纹的set。如果是True, 就表示要持久化存储, 就不清空数据, 否则清空数据
SCHEDULER_PERSIST = True  

    #指定redis服务
    	REDIS_HOST = ‘redis服务的ip地址‘
		REDIS_PORT = 6379
        
#4.对redis配置文件进行配置 (redis.windows.conf)
	56行 :  #bind 127.0.0.1
    75行 :  protected-mode yes  --> protected-mode no
#5.携带配置文件启动redis服务   redis-server .\redis.windows.conf
	地址: E:\飞秋\爬虫+数据\tools\redis\Redis-x64-3.2.100
#6.启动redis客户端 :  redis-cli
#7.执行当前的工程
	进入到爬虫文件对应的目录中:scrapy runspider xxx.py
#8.向调度器队列中仍入一个起始的url:
	队列在哪里呢?
    答:队列在redis中		lpush fbsQueue www.xxx.com

技术图片

  • 代码

    fbs.py

    import scrapy
    from scrapy.linkextractors import LinkExtractor
    from scrapy.spiders import CrawlSpider, Rule
    from scrapy_redis.spiders import RedisCrawlSpider
    from fbsPro.items import FbsproItem
    
    class FbsSpider(RedisCrawlSpider):
        name = ‘fbs‘
        # allowed_domains = [‘www.xxx.com‘]
        # start_urls = [‘http://www.xxx.com/‘]
    
        # redis_key表示的是可被共享调度器中队列的名称
        redis_key = ‘fbsQueue‘
    
        rules = (
            Rule(LinkExtractor(allow=r‘type=4&page=\d+‘), callback=‘parse_item‘, follow=True),
        )
    
        def parse_item(self, response):
            tr_list = response.xpath(‘//*[@id="morelist"]/div/table[2]//tr/td/table//tr‘)
            for tr in tr_list:
                title = tr.xpath(‘./td[2]/a[2]/@title‘).extract_first()
                status = tr.xpath(‘./td[3]/span/text()‘).extract_first()
    
                item = FbsproItem()
                item[‘title‘] = title
                item[‘status‘] = status
                yield item
    

    items.py

    import scrapy
    
    
    class FbsproItem(scrapy.Item):
        title = scrapy.Field()
        status = scrapy.Field()
    

    settings.py

    BOT_NAME = ‘fbsPro‘
    
    SPIDER_MODULES = [‘fbsPro.spiders‘]
    NEWSPIDER_MODULE = ‘fbsPro.spiders‘
    
    ROBOTSTXT_OBEY = True
    
    #开启可被共享的管道
    ITEM_PIPELINES = {
        ‘scrapy_redis.pipelines.RedisPipeline‘: 400
    }
    
    #指定可被共享的调度器
    # 增加了一个去重容器类的配置, 作用使用Redis的set集合来存储请求的指纹数据, 从而实现请求去重的持久化
    DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
    # 使用scrapy-redis组件自己的调度器
    SCHEDULER = "scrapy_redis.scheduler.Scheduler"
    # 配置调度器是否要持久化, 也就是当爬虫结束了, 要不要清空Redis中请求队列和去重指纹的set。如果是True, 就表示要持久化存储, 就不清空数据, 否则清空数据
    SCHEDULER_PERSIST = True
    
    #指定redis服务
    REDIS_HOST = ‘192.168.11.50‘
    REDIS_PORT = 6379
    

7.8 增量式爬虫

python爬虫入门 之 移动端数据的爬取

标签:分布   抓包工具   形式   tor   aik   过滤   you   property   print   

原文地址:https://www.cnblogs.com/lilinyuan5474/p/11498017.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!