爬虫之Scrapy框架

文章目录

    • 1. Scrapy 介绍
    • 2. 基础使用
      • 2.1 安装
      • 2.2 创建项目
      • 2.3 目录介绍
      • 2.4 创建爬虫
      • 2.5 运行爬虫
    • 3. scrapy 解析数据
    • 4. settings 相关配置
      • 4.1 基础配置
      • 4.2 提高爬虫效率配置
    • 5. 数据持久化
      • 5.1 方案一
      • 5.2 方案二(pipline模式)
        • 博客园全站爬取
    • 6. 下载中间件
    • 7. 下载中间件相关
      • 7.1 添加代理
      • 7.2 添加cookie
      • 7.3 修改请求头
      • 7.4 随机生成 UserAgent
      • 7.5 集成 selenium
    • 8. 去重规则源码分析
    • 9. python 中实现布隆过滤器
      • 9.1 布隆过滤器简介
      • 9.2 Python 中使用布隆过滤器
      • 9.3 在 Scrapy 中使用
    • 10. scrapy-redis 实现分布式爬虫

1. Scrapy 介绍

官方文档:https://docs.scrapy.org/en/latest/topics/architecture.html

Scrapy一个开源和协作的框架,其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的,使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。但目前Scrapy的用途十分广泛,可用于如数据挖掘、监测和自动化测试等领域,也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。

Scrapy 是基于twisted框架开发而来,twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞(又名异步)的代码来实现并发。整体架构大致如下
爬虫之Scrapy框架_第1张图片
Components:

  1. 引擎(EGINE)
    引擎负责控制系统所有组件之间的数据流,并在某些动作发生时触发事件。有关详细信息,请参见上面的数据流部分。

  2. 调度器(SCHEDULER)
    用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
    队列:先进先出,实现深度优先
    栈:后进先出,实现广度优先
    优先级队列:实现优先级

  3. 下载器(DOWLOADER)
    用于下载网页内容, 并将网页内容返回给EGINE,下载器是建立在twisted这个高效的异步模型上的

  4. 爬虫(SPIDERS)
    SPIDERS是开发人员自定义的类,用来解析responses,并且提取items,或者发送新的请求

  5. 项目管道(ITEM PIPLINES)
    在items被提取后负责处理它们,主要包括清理、验证、持久化(比如存到数据库)等操作

  6. 下载器中间件(Downloader Middlewares)
    位于Scrapy引擎和下载器之间,主要用来处理从EGINE传到DOWLOADER的请求request,已经从DOWNLOADER传到EGINE的响应response,你可用该中间件做以下几件事
    1、process a request just before it is sent to the Downloader (i.e. right before Scrapy sends the request to the website);
    2、change received response before passing it to a spider;
    3、send a new Request instead of passing received response to a spider;
    4、pass response to a spider without fetching a web page;
    silently drop some requests.

  7. 爬虫中间件(Spider Middlewares)
    位于EGINE和SPIDERS之间,主要工作是处理SPIDERS的输入(即responses)和输出(即requests)

2. 基础使用

2.1 安装

pip3 install scrapy

Windows平台如果安装不了则需要如下配置


    6、下载twisted的wheel文件:http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
    7、执行pip3 install 下载目录\Twisted-17.9.0-cp36-cp36m-win_amd64.whl
    8、pip3 install scrapy

#Linux平台
    1、pip3 install scrapy

  • 安装 wheel 、lxml
pip3 install wheel # 安装后,便支持通过wheel文件安装软件,wheel文件官网https://www.lfd.uci.edu/~gohlke/pythonlibs
pip3 install lxml
pip3 install pyopenssl
  • 安装 pywin32
    官方网站:https://sourceforge.net/projects/pywin32/files/pywin32/
    下载好打开该文件按流程走即可
    爬虫之Scrapy框架_第2张图片
  • 下载 twisted 的 wheel 文件
    官方网站:http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
    找到对应的版本下载,如果不知道支持的版本可以使用下面的命令

爬虫之Scrapy框架_第3张图片

  • 查看支持的版本
    查看 pip 支持的版本
python3 -m pip debug --verbose

爬虫之Scrapy框架_第4张图片

  • 最后安装 scrapy
pip3 install scrapy

2.2 创建项目

安装完成后在解释器的 Scripts 目录下会多出 scrapy.exe 文件,相当于 django 的 django_admin.exe 文件。

在这里插入图片描述

  • 创建项目命令
    创建项目只能使用命令的方式
scrapy startproject 项目名字

创建完成如下图所示

爬虫之Scrapy框架_第5张图片

2.3 目录介绍

firstscrapy         	# 项目名
    firstscrapy     	# 项目同名文件夹
        spiders     	# 文件夹,存放一个个爬虫
            cnblogs.py 	# 其中一个爬虫,重点写代码的地方(解析数据,发起请求)
        items.py    	# 类比 djagno 的 models,表模型(类)         
        middlewares.py 	# 中间件,爬虫中间件和下载中间件都在里面  
        pipelines.py   	# 管道,做持久化需要在这写代码           
        settings.py    	# 配置文件                             
    scrapy.cfg    		# 上线配置,开发阶段不用

2.4 创建爬虫

scrapy genspider 爬虫名字 爬取的初始网站
scrapy genspider cnblogs cnblogs.com

2.5 运行爬虫

scrapy crawl 爬虫名字

# --nolog 表示不打印日志
scrapy crawl 爬虫名字 --nolog

除了使用命令,还可以在 pycharm 中项目的根目录下创建 main.py 文件(文件名随意),添加如下内容

from scrapy.cmdline import execute

# execute(['scrapy','crawl','爬虫名','--nolog']) --nolog 表示不打印日志
execute(['scrapy','crawl','cnblogs','--nolog'])

3. scrapy 解析数据

第一个请求定义在 start_requests() 方法内默认从 start_urls 列表中获得 url 地址来生成 Request请求,默认的回调函数是 parse 方法。回调函数在下载完成返回 response 时自动触发,在回调函数中,可以解析 response 并且返回值

解析的方式通常使用 Scrapy 自带的 Selectors,也可以使用 Beutifulsoup,lxml或其他。最后,针对返回的Items对象将会被持久化到 Mysql、redis 或者文件中。

Spiders总共提供了五种类:

导入语句: from scrapy.spiders import Spider,CrawlSpider,XMLFeedSpider,CSVFeedSpider,SitemapSpider

1、scrapy.spiders.Spider 		#scrapy.Spider等同于scrapy.spiders.Spider
2、scrapy.spiders.CrawlSpider
3、scrapy.spiders.XMLFeedSpider
4、scrapy.spiders.CSVFeedSpider
5、scrapy.spiders.SitemapSpider
class CnblogsSpider(scrapy.Spider):
    name = 'cnblogs'
    allowed_domains = ['cnblogs.com']
    start_urls = ['http://cnblogs.com/']

    def parse(self, response):
        print(response.text)
  • 解析数据
response 对象有css方法和xpath方法,在css中使用css选择器,在xpath中写xpath选择器

	xpath取文本内容
	'.//a[contains(@class,"link-title")]/text()'
    xpath取属性
    './/a[contains(@class,"link-title")]/@href'
    css取文本  ::text
    'a.link-title::text'
    css取属性  ::attr()
    'img.image-scale::attr(src)'

	.extract_first()  取一个
    .extract()        取所有

属性方法介绍

  • name = ‘cnblogs’
定义爬虫名,scrapy 会根据该值定位爬虫程序,所以它必须要有且必须唯一
  • allowed_domains = [‘cnblogs.com’]
定义允许爬取的域名,如果OffsiteMiddleware启动(默认就启动),那么不属于该列表的域名及其子域名
都不允许爬取如果爬取的网址为:https://www.example.com/1.html,那就添加'example.com'到列表.
  • start_urls = [‘http://cnblogs.com/’]
如果没有指定 url,就从该列表中读取 url 来生成第一个请求
  • custom_settings
值为一个字典,定义一些配置信息,在运行爬虫程序时,这些配置会覆盖项目级别的配置,所以
custom_settings必须被定义成一个类属性,由于settings会在类实例化前被加载
  • settings
通过 self.settings['配置项的名字'] 可以访问 settings.py 中的配置,如果优先使用自己定义的
custom_settings 配置
  • logger
日志名默认为spider的名字
self.logger.debug('=============>%s' %self.settings['BOT_NAME'])
  • start_requests()
该方法用来发起第一个Requests请求,且必须返回一个可迭代的对象。它在爬虫程序打开时就被Scrapy调用
Scrapy只调用它一次。默认从start_urls里取出每个url来生成Request(url, dont_filter=True)
#针对参数dont_filter,请看自定义去重规则

如果你想要改变起始爬取的Requests,你就需要覆盖这个方法,例如你想要起始发送一个POST请求,如下
class MySpider(scrapy.Spider):
    name = 'myspider'

	def start_requests(self):
	    return [scrapy.FormRequest("http://www.example.com/login",
	                               formdata={'user': 'xxx', 'pass': '123'},
	                               callback=self.logged_in)]

	def logged_in(self, response):
	    # here you would extract links to follow and return Requests for
	    # each of them, with another callback
	    pass
	    
  • parse(response)
这是默认的回调函数,所有的回调函数必须返回Request和/或dicts或Item对象的可迭代对象。
  • closed(reason)
爬虫程序结束时自动触发

解析博客园文章数据

import scrapy


class CnblogsSpider(scrapy.Spider):
    name = 'cnblogs'
    allowed_domains = ['cnblogs.com']
    start_urls = ['http://cnblogs.com/']
    custom_settings = {}

    def parse(self, response):
        article_list = response.css('article.post-item')
        for article in article_list:
            title = article.css('a.post-item-title::text').extract_first()
            # title = article.xpath('.//a/text()').extract_first()
            
            desc = article.css('p.post-item-summary::text').extract()
            # desc = article.xpath('./section/div/p/text()').extract()
            
            real_desc = desc[0].replace('\n', '').replace(' ', '')
            if not real_desc:
                real_desc = desc[1].replace('\n', '').replace(' ', '')
                
            pub_time = article.css('span.post-meta-item>span::text').extract_first()
            # pub_time=article.xpath('.//footer/span/span/text()').extract_first()
            
            author = article.css('footer.post-item-foot span::text').extract_first()
			# author=article.xpath('.//footer/a/span/text()').extract_first()

            url = article.css('a.post-item-title::attr(href)').extract_first()
            # url = article.xpath('./section/div/a/@href').extract_first()
            

4. settings 相关配置

4.1 基础配置

配置 说明
ROBOTSTXT_OBEY True / False 是否遵循爬虫协议
LOG_LEVEL ‘ERROR’ / ‘INFO’ /… 日志级别
USER_AGENT Mozilla/5.0 (Windows NT 10.0;… 用户代理
DEFAULT_REQUEST_HEADERS 如下所示 默认请求头
SPIDER_MIDDLEWARES 如下所示 爬虫中间件
DOWNLOADER_MIDDLEWARES 如下所示 下载中间件
ITEM_PIPELINES 如下所示 持久化配置
CONCURRENT_REQUESTS 默认 16 配置Scrapy执行的最大并发请求
COOKIES_ENABLED 默认 True 是否禁止 cookie
RETRY_ENABLED True / False 是否重试
DOWNLOAD_TIMEOUT 数字 超时等待时间
# 默认请求头
DEFAULT_REQUEST_HEADERS = {
  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  'Accept-Language': 'en',
}
# 爬虫中间件
SPIDER_MIDDLEWARES = {
   'myfirstscrapy.middlewares.MyfirstscrapySpiderMiddleware': 543,
}
# 持久化配置
ITEM_PIPELINES = {
   'myfirstscrapy.pipelines.MyfirstscrapyPipeline': 300,
}

4.2 提高爬虫效率配置

  • 增加并发
CONCURRENT_REQUESTS = 100
默认 scrapy 开启的并发线程为 16 个,可以适当进行增加。在 settings 配置文件中如上修改为100
  • 降低日志级别
在运行scrapy时,会有大量日志信息的输出,为了减少CPU的使用率。可以设置log输出信息为ERROR。
在配置文件中编写:	LOG_LEVEL = 'ERROR'
  • 禁止 cookie
如果不是真的需要cookie,则在scrapy爬取数据时可以禁止cookie从而减少CPU的使用率,提升爬取效率。
在配置文件中编写:COOKIES_ENABLED = False
  • 禁止重试
对失败的HTTP进行重新请求(重试)会减慢爬取速度,因此可以禁止重试。在配置文件中编写:
RETRY_ENABLED = False
  • 减少下载超时
如果对一个非常慢的链接进行爬取,减少下载超时可以能让卡住的链接快速被放弃,从而提升效率。
在配置文件中进行编写:DOWNLOAD_TIMEOUT = 10  # 超时时间为10s

5. 数据持久化

解析好的数据需要进行存储,存储的形式可以是文件、redis、MySQL等等。

5.1 方案一

一般不使用该方法

1. 解析函数parse返回的格式需要如下形式:
	return [{},{},{}]
2. 运行如下命令
	scrapy crawl cnblogs -o 文件名(json,pkl,csv结尾)

5.2 方案二(pipline模式)

  1. 在 items.py 中写一个类,继承 scrapy.Item,并在类中写属性
class CnBlogItem(scrapy.Item):
    title = scrapy.Field()
    author = scrapy.Field()
    real_desc = scrapy.Field()
    pub_time = scrapy.Field()
    url = scrapy.Field()
    content = scrapy.Field()
  1. 在爬虫中导入类,实例化得到对象,把要保存的数据放到对象中
import scrapy
from myfirstscrapy.items import CnBlogItem

class CnblogsSpider(scrapy.Spider):
    name = 'cnblogs'
    allowed_domains = ['cnblogs.com']
    start_urls = ['http://cnblogs.com/']

    def parse(self, response):
        
        for article in article_list:
        	item = CnBlogItem()
            ...
            item['title'] = title
            item['real_desc'] = real_desc
            item['pub_time'] = pub_time
            item['author'] = author
            item['url'] = url
	
            yield item


  1. 修改配置文件,指定 pipline,数字表示优先级,越小越大
ITEM_PIPELINES = {
   'myfirstscrapy.pipelines.CnBlogPipeline': 300,
}
  1. 编写注册的 pipline
class CnBlogPipeline:
    def open_spider(self, spider):
        # 数据初始化,打开文件,打开数据库链接
        # 打开文件,链接数据库
        self.f = open('cnblogs.txt', 'w', encoding='utf-8')

    def process_item(self, item, spider):
        # 储存数据,必须返回 item 给后续的 pipline 继续使用
        self.f.write('标题:%s,作者:%s\n' % (item['title'], item['author']))
        return item

    def close_spider(self, spider):
        # 销毁资源,关闭文件,关闭数据库链接
        # 关闭文件,关闭数据库
        self.f.close()

博客园全站爬取
  • cnblogs.py 爬虫文件
import scrapy
from myfirstscrapy.items import CnBlogItem
from scrapy import Request


class CnblogsSpider(scrapy.Spider):
    # 爬虫名字
    name = 'cnblogs'
    # 域名
    allowed_domains = ['cnblogs.com']
    # 爬取地址
    start_urls = ['http://cnblogs.com/']

    # 回调函数
    def parse(self, response):
        # 获取一页文章内容
        article_list = response.css('article.post-item')
        for article in article_list:
            # 实例化 Items.py 下的类
            item = CnBlogItem()

            title = article.css('a.post-item-title::text').extract_first()
            desc = article.css('p.post-item-summary::text').extract()
            real_desc = desc[0].replace('\n', '').replace(' ', '')
            if not real_desc:
                real_desc = desc[1].replace('\n', '').replace(' ', '')
            pub_time = article.css('span.post-meta-item>span::text').extract_first()
            author = article.css('footer.post-item-foot span::text').extract_first()
            url = article.css('a.post-item-title::attr(href)').extract_first()

            # 给 item 设置文章内容
            item['title'] = title
            item['desc'] = real_desc
            item['pub_time'] = pub_time
            item['author'] = author
            item['url'] = url

            # 发起请求,获取文章详情(另一个页面),回调函数设置为 parser_detail,并通过 meta 实现请求对象和响应对象通信
            yield Request(url=url, callback=self.parser_detail, meta={'item': item})

        # 获取下一页元素链接属性
        next = response.css('div.pager>a:last-child::attr(href)').extract_first()
        # 拼接地址
        next = 'https://www.cnblogs.com' + next
        print(next)
        # 发起请求,设置回调函数为 parse,当然默认也是 parse
        yield Request(url=next, callback=self.parse)

    def parser_detail(self, response):
        # 获取传递的 item,用于数据持久化
        item = response.meta.get('item')
        # 获取文章内容
        content = response.css('#cnblogs_post_body').extract_first()
        # 添加属性
        item['content'] = content
        yield item

  • items.py
import scrapy

class CnBlogItem(scrapy.Item):
    title = scrapy.Field()
    author = scrapy.Field()
    desc = scrapy.Field()
    pub_time = scrapy.Field()
    url = scrapy.Field()
    content = scrapy.Field()
  • settings.py
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36'

ITEM_PIPELINES = {
    'myfirstscrapy.pipelines.CnBlogPipeline': 300,
}
  • pipelines.py
import pymysql

class CnBlogPipeline:
    def open_spider(self, spider):
        # 数据初始化,使用 pymysql 打开数据库链接
        self.conn = pymysql.connect(user='root',
                                    password="123123",
                                    host='127.0.0.1',
                                    port=3306,
                                    database='cnblogs')
        self.cursor = self.conn.cursor()

    def process_item(self, item, spider):
        # 编写 sql 语句,例如 desc 这种本身属于关键词的可以使用 `` 包裹,编写的占位符使用 %s
        sql = 'insert into cnblog (title,`desc`,url,pub_time,author,content) values (%s,%s,%s,%s,%s,%s)'
        # 传入参数
        self.cursor.execute(sql, args=[item['title'], item['desc'], item['url'], item['pub_time'], item['author'],
                                       item['content']])
        # 提交确认
        self.conn.commit()

        # 储存数据,必须返回 item 给后续的 pipline 继续使用
        return item

    def close_spider(self, spider):
        # 销毁资源,关闭文件,关闭数据库链接
        self.cursor.close()
        self.conn.close()

6. 下载中间件

中间件中 SPIDER_MIDDLEWARES 爬虫中间件 (了解即可,用的少),DOWNLOADER_MIDDLEWARES 下载中间件(用的多)。尤其是下载中间件,里面的两个方法
process_requestprocess_response

class CnBlogDownloaderMiddleware:
    @classmethod
    def from_crawler(cls, crawler):
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
    	# 请求来的时候执行
        # return None 					继续处理此请求
        # return a Response object 		返回给 engin,去解析
        # return a Request object		返回给 engin,继续去请求
        # raise IgnoreRequest: 			执行 process_exception 方法
        return None

    def process_response(self, request, response, spider):
    	# 请求走的时候执行

        # return a Response object	继续走下一个中间件的process_response,给engin,去解析
        # return a Request object	给engin,进入调度器,等待下一次爬取
        # raise IgnoreRequest		抛出异常
        return response

    def process_exception(self, request, exception, spider):
		# 出现异常时执行
        pass

    def spider_opened(self, spider):
    	# 爬虫运行时执行
        spider.logger.info('Spider opened: %s' % spider.name)

需要在 settings.py 中配置:

DOWNLOADER_MIDDLEWARES = {
   'myfirstscrapy.middlewares.CnBlogDownloaderMiddleware': 543,
}

7. 下载中间件相关

7.1 添加代理

在下载中间件的 process_request 方法中如下配置:

...
    def process_request(self, request, spider):
    	# 这里是固定的,最好搭建一个代理池,每次随机取出一个使用
        request.meta['proxy'] = 'http://221.6.215.202:9091'
        return None
...

7.2 添加cookie

在下载中间件的 process_request 方法中如下配置:

...
    def process_request(self, request, spider):
        request.cookies['name'] = 'xwx'
        request.cookies = {}
        return None
...

7.3 修改请求头

在下载中间件的 process_request 方法中如下配置:

...
    def process_request(self, request, spider):
    	# cookie 也可以写在请求头
		request.headers['Auth'] = 'asdfasdfasdfasdf'
		request.headers['USER-AGENT'] = 'ssss'
        return None
...

7.4 随机生成 UserAgent

需要使用 fake_useragent 模块
pip3 install fake-useragent
在下载中间件的 process_request 方法中如下配置:

...
    def process_request(self, request, spider):
		from fake_useragent import UserAgent
		ua = UserAgent()
        print(ua.ie)   		# 随机打印ie浏览器任意版本
        print(ua.firefox) 	# 随机打印firefox浏览器任意版本
        print(ua.chrome)  	# 随机打印chrome浏览器任意版本
        print(ua.random)  	# 随机打印任意厂家的浏览器 
        request.headers['USER-AGENT'] = ua.chrome
        return None
...

7.5 集成 selenium

  • 在爬虫类中如下配置
...
from selenium import webdriver

class CnblogsSpider(scrapy.Spider):
	...
	chrome = webdriver.Chrome()
	...
	def close(spider, reason):
		# 关闭浏览器
        spider.chrome.close()

  • 在中间件中的 process_reqeust 中配置:
...
    def process_request(self, request, spider):
        from scrapy.http import HtmlResponse
        url = request.url
        if 'sitehome' in url:
            spider.chrome.get(url=url)
            response = HtmlResponse(url=request.url, body=spider.chrome.page_source.encode('utf-8'), request=request)
            return response
        else:
            return None
...

8. 去重规则源码分析

scrapy 使用集合实现了去重,也就是爬过的网址不会再爬了。

DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'

# from scrapy.dupefilters import RFPDupeFilter
class RFPDupeFilter(BaseDupeFilter)
	def request_seen(self, request: Request) -> bool:
        # 把request生成指纹,如果request对象的url一样,指纹就一样
        fp = self.request_fingerprint(request)
        if fp in self.fingerprints:
            return True
        self.fingerprints.add(fp)
        if self.file:
            self.file.write(fp + '\n')
        return False

  • 爬虫开始爬取时,执行了爬虫类对象的:start_requests 方法
  • start_urls 是起始爬取的地址
  • 爬虫去重的规则应该在 scrapy.core.scheduler 调度器源码中的 enqueue_request 中调用了去重类(RFPDupeFilter)对象的 request_seen 方法来完成去重,本质是使用集合去重的
  • 每次爬取的地址对象 request 生成一个指纹,判断是否在集合中,如果在集合中,就不爬取了,如果不在,就爬取并且把生成的指纹放到集合中
  • 把下面这种地址生成指纹后,生成的是一样的:
www.cnblogs.com?name=xwx&age=19
www.cnblogs.com?age=19&name=xwx

测试生成指纹

from scrapy.utils.request import request_fingerprint
from scrapy import Request
ur1=Request(url='http://www.cnblogs.com?name=xwx&age=19')
ur2=Request(url='http://www.cnblogs.com?age=20&name=xwx')
print(request_fingerprint(ur1))
print(request_fingerprint(ur2))

集合的方式如果爬取的网址少还行,如果特别多 ,则会占非常大的内存空间。可以使用 布隆过滤器 来实现极小空间实现去重

9. python 中实现布隆过滤器

9.1 布隆过滤器简介

bloomfilter:是一个通过多哈希函数映射到一张表的数据结构,能够快速的判断一个元素在一个集合内是否存在,具有很好的空间和时间效率。(典型例子,爬虫url去重)

原理: BloomFilter 会开辟一个m位的bitArray(位数组),开始所有数据全部置 0 。当一个元素过来时,能过多个哈希函数(h1,h2,h3…)计算不同的在哈希值,并通过哈希值找到对应的bitArray下标处,将里面的值 0 置为 1 。

关于多个哈希函数,它们计算出来的值必须 [0,m) 之中。

假设长度为 20的bitArray,通过 3 个哈希函数求值。如下图:

爬虫之Scrapy框架_第6张图片

另外说明一下,当来查找对应的值时,同样通过哈希函数求值,再去寻找数组的下标,如果所有下标都为1时,元素存在。当然也存在错误率。(如:当数组全部为1时,那么查找什么都是存在的),但是这个错误率的大小,取决于数组的位数和哈希函数的个数。

9.2 Python 中使用布隆过滤器

安装:pip3 install pybloom_live

# pybloom_live 依赖这个包,直接安装 pybloom_live 会自动下载依赖的包
pip3 install bitarray-0.8.1-cp36-cp36m-win_amd64.whl
  • 示例一
# ScalableBloomFilter 可以自动扩容
from pybloom_live import ScalableBloomFilter
​
​# 错误达到 0.001 自动扩容
bloom = ScalableBloomFilter(initial_capacity=100, error_rate=0.001, mode=ScalableBloomFilter.LARGE_SET_GROWTH)
​
url = "www.cnblogs.com"
​
url2 = "www.liuqingzheng.top"
​
bloom.add(url)print(url in bloom)print(url2 in bloom)
  • 示例二
# BloomFilter 是定长的
from pybloom_live import BloomFilter
​
bf = BloomFilter(capacity=1000)
url='www.baidu.com'
bf.add(url)print(url in bf)print("www.liuqingzheng.top" in bf)

9.3 在 Scrapy 中使用

  • my_filter.py 文件下创建类,替换掉内置的去重
from pybloom_live import ScalableBloomFilter
from scrapy.dupefilters import RFPDupeFilter


class MyRFPDupeFilter(RFPDupeFilter):
    bloom = ScalableBloomFilter(initial_capacity=100, error_rate=0.001, mode=ScalableBloomFilter.LARGE_SET_GROWTH)
    fingerprints = bloom

    def request_seen(self, request):
        fp = self.request_fingerprint(request)
        if fp in self.fingerprints:
            return True
        self.fingerprints.add(fp)
        if self.file:
            self.file.write(fp + '\n')
        return False

  • settings.py 配置
DUPEFILTER_CLASS = 'myfirstscrapy.my_filter.MyRFPDupeFilter'

10. scrapy-redis 实现分布式爬虫

  1. 第一步:安装 scrapy-redis
    安装:pip3 install scrapy-redis
  2. 第二步:改造爬虫类
from scrapy_redis.spiders import RedisSpider
   class CnblogSpider(RedisSpider):
       name = 'cnblog_redis'
       allowed_domains = ['cnblogs.com']
       # 写一个key:redis列表的key,起始爬取的地址
       redis_key = 'myspider:start_urls'
  1. 第三步:配置文件配置
# 分布式爬虫配置
# 去重规则使用redis
REDIS_HOST = 'localhost'                            # 主机名
REDIS_PORT = 6379                                   # 端口
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 持久化:文件,mysql,redis
ITEM_PIPELINES = {
   'cnblogs.pipelines.CnblogsFilePipeline': 300,
   'cnblogs.pipelines.CnblogsMysqlPipeline': 100,
   'scrapy_redis.pipelines.RedisPipeline': 400,
}
  1. 第四步:在多台机器上启动scrapy项目
  2. 第五步:手动把起始爬取的地址放到 redis 的列表中
lpush myspider:start_urls value http://www.cnblogs.com/

你可能感兴趣的:(爬虫,爬虫,scrapy,数据挖掘)