前言：
使用 requests + Beautifulsoup的爬虫模式，随着业务的扩展，会遇到 性能、数据快速存储、多爬虫统一管理的问题，所以选择了爬虫框架----Scrapy！
Scrapy爬虫介绍
Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架。 其可以应用在数据挖掘，信息处理或存储历史数据等一系列的程序中。
其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的， 也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。Scrapy用途广泛，可以用于数据挖掘、监测和自动化测试。
Scrapy功能
----引用twisted模块异步下载页面
-----HTML解析成对象
-----代理
----延迟下载
----URL字段去重
----指定深度、广度
...........................
Scrapy架构及工作流程
Scrapy 使用了 Twisted异步网络库来处理网络通讯。整体架构大致如下
Scrapy主要包括了以下组件：
引擎(Scrapy)
用来处理整个系统的数据流处理, 触发事务(框架核心)
调度器(Scheduler)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL（抓取网页的网址或者说是链接）的优先队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
下载器(Downloader)
用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立在twisted这个高效的异步模型上的)
爬虫(Spiders)
爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体(Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
项目管道(Pipeline)
负责处理爬虫从网页中抽取的实体，主要的功能是持久化实体、验证实体的有效性、清除不需要的信息。当页面被爬虫解析后，将被发送到项目管道，并经过几个特定的次序处理数据。
下载器中间件(Downloader Middlewares)
位于Scrapy引擎和下载器之间的框架，主要是处理Scrapy引擎与下载器之间的请求及响应。
爬虫中间件(Spider Middlewares)
介于Scrapy引擎和爬虫之间的框架，主要工作是处理蜘蛛的响应输入和请求输出。
调度中间件(Scheduler Middewares)
介于Scrapy引擎和调度之间的中间件，从Scrapy引擎发送到调度的请求和响应。
Scrapy运行流程大概如下：
1.程序员在Spiders里定义爬虫的起始URL。
2.ScrapyEngine把Spider中的起始URL，推送到Scheduler。
3.Scheduler调度URL通过Downloader去互联网下载HTML内容。
4.Downloader下载HTML内容并返回给Spiders（回调函数）。
5.Spiders调用 Item Pipeline把爬到的内容保存的数据库/文件，或者继续循环流程1-5。
Scrapy安装&使用
安装
1.Linux
pip install scrapy
2.Windows
2.1：下载twisted
Twisted‑18.7.0‑cp36‑cp36m‑win_amd64.whl：cp36是cpython解释器的版本，amd64Windows的位数；
2.2：安装scrapy
pip install scrapy -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
基本使用
scrapy startproject projectname #创建1个Scrapy项目
cd projectnamescrapy genspider [-t template] <name> <domain> #创建爬虫应用scrapy gensipider-t basic le le.com #创建虫子1scrapy gensipider-t xmlfeed bestseller.com.cn #创建虫子2scrapylist #展示爬虫应用列表scrapy crawl 爬虫应用名 --nolog #运行单独爬虫应用 --nolog不打印日志
修改setings.py
ROBOTSTXT_OBEY = False：是否遵守爬虫协议
建议读者一定要遵循爬虫协议，如果ROBOTSTXT_OBEY = True，不能获取到respose一点要和对方打电话谈谈！
爬虫开始。。。
# -*- coding: utf-8 -*- import scrapy # import sys,os,io # sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gb18030') #解决编码错误 class BaiduSpider(scrapy.Spider): name = 'baidu' allowed_domains = ['baidu.com'] #起始URL start_urls = ['http://baidu.com/'] #限制域名 def parse(self, response): #回调函数 print(response.text)
选择器
# -*- coding: utf-8 -*- import scrapy from scrapy.selector import Selector, HtmlXPathSelector from scrapy.http import HtmlResponse # import sys,os,io # sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gb18030') #解决编码错误 class BaiduSpider(scrapy.Spider): name = 'baidu' allowed_domains = ['baidu.com'] #起始URL start_urls = ['http://baidu.com/'] #限制域名 def parse(self, response): #回调函数 html = """<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> <ul> <li class="item-"><a id='i1' href="link.html">first item</a></li> <li class="item-0"><a id='i2' href="llink.html">first item</a></li> <li class="item-1"><a href="llink2.html">second item<span>vv</span></a></li> </ul> <div><a href="llink2.html">second item</a></div> </body> </html> """ response = HtmlResponse(url='http://example.com', body=html, encoding='utf-8') # hxs=Selector(response=response).xpath('//a') #查询所有a标签 # hxs = Selector(response=response).xpath('//a[@id]') #查询包含id属性的a标签 #hxs = Selector(response=response).xpath('//a[@id="i1"]') #查询id=i1的a标签 #hxs = Selector(response=response).xpath('//a[@href="link.html"][@id="i1"]') #查询href="link.html" &id="i1"的a标签 # hxs = Selector(response=response).xpath('//a[contains(@href, "link")]') #查询href="link.html"包含link关键字的a标签 #hxs = Selector(response=response).xpath('//a[starts-with(@href, "link")]') # 查询href="link.html"以link关键字开头的a标签 #使用正则匹配 #hxs = Selector(response=response).xpath('//a[re:test(@id, "id+")]') #查询id为 i数字 的a标签 #hxs = Selector(response=response).xpath('//a[re:test(@id, "id+")]/text()').extract() #/text()获取文本内容 # hxs = Selector(response=response).xpath('//a[re:test(@id, "id+")]/@href').extract() #/@href获取href属性 # hxs = Selector(response=response).xpath('/html/body/ul/li/a/@href').extract() #python数据类型 # hxs = Selector(response=response).xpath('//body/ul/li/a/@href').extract_first() #获取匹配到的第一个a标签 ul_list = Selector(response=response).xpath('//body/ul/li') #支持for循环 for item in ul_list: v = item.xpath('./a/span')#相对当前标签下寻找子代 ./，*/，a #注意//遍历所有后代， /遍历所有子代 # 或 # v = item.xpath('a/span') # 或 # v = item.xpath('*/a/span') print(v)
# -*- coding: utf-8 -*- import scrapy,urllib.parse from scrapy.http import Request from scrapy.selector import Selector from scrapy.http.cookies import CookieJar class ChoutiSpider(scrapy.Spider): name = 'chouti' allowed_domains = ['chouti.com'] start_urls = ['http://chouti.com/'] cookie_dict = {} ''' 1. 发送一个GET请求,抽屉 获取cookie 2. 用户密码POST登录：携带上一次cookie 返回值：9999 3. 为为所欲为，携带cookie ''' def start_requests(self):#子类重写父类的start_requests，指定其实url for url in self.start_urls: yield Request(url,dont_filter=True,callback=self.index) def index(self,response):#首页 cookie_jar=CookieJar() #提取本次请求的cokie，保存到cookie_jar对象 cookie_jar.extract_cookies(response, response.request)#去响应中获取cookie #把cookie保存到字典 for k, v in cookie_jar._cookies.items(): for i, j in v.items(): for m, n in j.items(): self.cookie_dict[m] = n.value post_dict={ "phone": '8613220198866', "password": "woshiniyeye", "oneMonth": 1, } yield Request( #发送post请求,进行登录 url='https://dig.chouti.com/login', method='POST', cookies= self.cookie_dict, headers = {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'}, body=urllib.parse.urlencode(post_dict), callback=self.login ) def login(self,response) : yield Request(url='https://dig.chouti.com/',cookies=self.cookie_dict,callback=self.get_news) def get_news(self,response): hxs=Selector(response) link_id_list=hxs.xpath('//div[@class="part2"]/@share-linkid').extract() #获取新闻ID for link in link_id_list: base_url = "http://dig.chouti.com/link/vote?linksId=%s" % (link) yield Request( url=base_url, method='POST', cookies=self.cookie_dict, callback=self.end_parse ) def end_parse(self,response): print(response.text)
Pipeline组件
序列化和存储爬取的数据，以下是使用方法，Pipline组件是全局生效的，这意味着所有的爬虫只要return了item对象，都会执行pipline组件。
如何在pipline区别每个爬虫做不同操作？
def process_item(self, item, spider): #爬虫爬取数据过程中 ''' 爬虫爬取数据过程中 :param item: 爬虫中yield回来的对象 :param spider:爬虫对象 obj= JandanSpider() :return: ''' if spider.name=='jandan': print(item) #将item传递给下一个pipline的 process_item方法，串起来执行！ return item
0.在scrapy项目setings.py配置文件注册pipeline
ITEM_PIPELINES = { 'sp2.pipelines.Sp2Pipeline': 300,#组册pipeline,300优先级值越小越先执行 }
1.在爬虫中yield Sp2Item()对象
from ..items import Sp2Item yield Sp2Item(url=url,text=text) #yeid item对象表示把标签内容交给 ItemPipeline组件！
2.在item中定义爬虫yield的字段
import scrapy class Sp2Item(scrapy.Item): url = scrapy.Field() #定义字段 text = scrapy.Field()
3.在pipelines设计爬取数据的存储逻辑
class Sp2Pipeline(object): def __init__(self): self.f = None def process_item(self, item, spider): #爬虫爬取数据过程中 ''' 爬虫爬取数据过程中 :param item: 爬虫中yield回来的对象 :param spider:爬虫对象 obj= JandanSpider() :return: ''' print(item) return item @classmethod def from_crawler(cls,crawler): #初始化时候，用于创建pipeline对象 """ 初始化时候，用于创建pipeline对象 :param crawler: :return: """ return cls() def open_spider(self, spider): #爬虫开始执行时，调用 """ 爬虫开始执行时，调用 :param spider: :return: """ print('爬虫开始！！') def close_spider(self, spider): #爬虫关闭时，被调用 """ 爬虫关闭时，被调用 :param spider: :return: """ print('爬虫结束')
scrapy中间件
scrapy和Django一样具有中间件功能，可以在scrapy请求网页和下载网页的过程中做统一操作，例如修改equest请求头加爬虫代理，设置response解码.....；
0.在scrapy项目setings.py配置文件注册中间件
SPIDER_MIDDLEWARES = { 'sp33.middlewares.Sp33SpiderMiddleware': 3, } # Enable or disable downloader middlewares # See https://doc.scrapy.org/en/latest/topics/downloader-middleware.html DOWNLOADER_MIDDLEWARES = { 'sp33.middlewares.Sp33DownloaderMiddleware': 543, }
1.爬虫中间件
class Sp33SpiderMiddleware(object): # Not all methods need to be defined. If a method is not defined, # scrapy acts as if the spider middleware does not modify the # passed objects. @classmethod def from_crawler(cls, crawler): # This method is used by Scrapy to create your spiders. #0、 创建爬虫的时候调用！ s = cls() #通过信号来扩展spider_opened crawler.signals.connect(s.spider_opened, signal=signals.spider_opened) return s def process_spider_input(self, response, spider): #3.当爬虫下载完毕，还没有经过parse处理之前调用； print('----------------------------------------------------process_spider_input') return None def process_spider_output(self, response, result, spider): print('------------------------------------------------------process_spider_input') #4.当爬虫下载完毕，经过parse处理之后调用。 # :return: 必须返回包含 Request 或 Item 对象的可迭代对象(iterable) for i in result: yield i def process_spider_exception(self, response, exception, spider): #触发异常是执行 #return: None,继续交给后续中间件处理异常；含 Response 或 Item 的可迭代对象(iterable)，交给调度器或pipeline pass def process_start_requests(self, start_requests, spider): print('-------------------------------------------------process_start_requests') #2.在爬虫启动的时 调用 start_requests # Must return only requests (not items). for r in start_requests: yield r def spider_opened(self, spider): #1在爬虫打开自己注册的信号 print('-------------------------------------------------------spider_opened') spider.logger.info('Spider opened: %s' % spider.name)
2.下载中间件
class Sp33DownloaderMiddleware(object): # Not all methods need to be defined. If a method is not defined, # scrapy acts as if the downloader middleware does not modify the # passed objects. @classmethod def from_crawler(cls, crawler): # This method is used by Scrapy to create your spiders. s = cls() crawler.signals.connect(s.spider_opened, signal=signals.spider_opened) return s def process_request(self, request, spider): """ spider处理完成，返回时调用 :param response: :param result: :param spider: :return: Response 对象：转交给其他中间件process_response Request 对象：停止中间件，request会被重新调度下载 raise IgnoreRequest 异常：调用Request.errback """ # Called for each request that goes through the downloader # middleware. # Must either: # - return None: continue processing this request # - or return a Response object # - or return a Request object # - or raise IgnoreRequest: process_exception() methods of # installed downloader middleware will be called return None def process_response(self, request, response, spider): """ spider处理完成，返回时调用 :param response: :param result: :param spider: :return: Response 对象：转交给其他中间件process_response Request 对象：停止中间件，request会被重新调度下载 raise IgnoreRequest 异常：调用Request.errback """ # Called with the response returned from the downloader. # Must either; # - return a Response object # - return a Request object # - or raise IgnoreRequest return response def process_exception(self, request, exception, spider): """ 当下载处理器(download handler)或 process_request() (下载中间件)抛出异常 :param response: :param exception: :param spider: :return: None：继续交给后续中间件处理异常； Response对象：停止后续process_exception方法 Request对象：停止中间件，request将会被重新调用下载 """ # Called when a download handler or a process_request() # (from other downloader middleware) raises an exception. # Must either: # - return None: continue processing this exception # - return a Response object: stops process_exception() chain # - return a Request object: stops process_exception() chain pass def spider_opened(self, spider): spider.logger.info('Spider opened: %s' % spider.name)
Scrapy扩展、定制
定制URL去重功能
scrapy默认自带&开启了url去重功能，是通过文件保存url访问记录实现的，所以可尝试自己扩展url去重功能，把数以万计的url记录到iowait更快的内存数据库中去！
1.设置去重规则
class RepeatUrl: def __init__(self): self.visited_url = set() # 放在当前服务的内存 @classmethod def from_settings(cls, settings): """ 初始化时，调用 :param settings: :return: """ return cls() def request_seen(self, request): """ 检测当前请求是否已经被访问过 :param request: :return: True表示已经访问过；False表示未访问过 """ print('============================================================='+request.url) if request.url in self.visited_url: return True self.visited_url.add(request.url) return False def open(self): """ 开始爬去请求时，调用 :return: """ print('open replication') def close(self, reason): """ 结束爬虫爬取时，调用 :param reason: :return: """ print('close replication') def log(self, request, spider): """ 记录日志 :param request: :param spider: :return: """ print('repeat', request.url)
2.在scrapy项目setings.py配置文件中注册
DUPEFILTER_CLASS = 'sp2.rep.RepeatUrl'
基于scrapy预留信号自定义扩展
scrapy是一个扩展性极好的框架，类似Django的信号，scrapy同样预留了许多信号钩子，以便我们在爬虫工作的任何环节，做各种自定制扩展。
engine_started
engine_stopped
spider_opened
spider_idle
spider_closed
spider_error
request_scheduled
request_dropped
response_received
response_downloaded
item_scraped
item_dropped
1.settings.py配置文件中注册信号
EXTENSIONS = { 'sp2.extends.MyExtension': 1,# 自定制信号的所在目录：优先级 }
2.扩展内容
from scrapy import signals class MyExtension(object): def __init__(self, value): self.value = value @classmethod def from_crawler(cls, crawler): val = crawler.settings.getint('MMMM') ext = cls(val) # 在scrapy中注册信号： spider_opened crawler.signals.connect(ext.opened, signal=signals.spider_opened) # 在scrapy中注册信号： spider_closed crawler.signals.connect(ext.closed, signal=signals.spider_closed) return ext def opened(self, spider): print('###########################打开爬虫###########################') def closed(self, spider): print('###########################关闭爬虫###########################') # engine_started = object() # engine_stopped = object() # spider_opened = object() # spider_idle = object() # spider_closed = object() # spider_error = object() # request_scheduled = object() # request_dropped = object() # response_received = object() # response_downloaded = object() # item_scraped = object() # item_dropped = object()
扩展scrapy执行命令
1.在spiders同级创建任意目录，如：commands
2.在其中创建 crawlall.py 文件 （此处文件名就是自定义的命令）
from scrapy.commands import ScrapyCommand from scrapy.utils.project import get_project_settings class Command(ScrapyCommand): requires_project = True def syntax(self): return '[options]' def short_desc(self): return 'Runs all of the spiders' def run(self, args, opts): spider_list = self.crawler_process.spiders.list() for name in spider_list: self.crawler_process.crawl(name, **opts.__dict__) self.crawler_process.start() crawlall.py
3.在settings.py 中添加配置 COMMANDS_MODULE = '项目名称.目录名称'
4.在项目目录执行命令：scrapy crawlall，一次启动所有爬虫；
.