Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架。 其可以应用在数据挖掘，信息处理或存储历史数据等一系列的程序中。
其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的， 也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。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运行流程大概如下（结合上图）：
- 每个 Spiders 都会有一个初始start_urls。（第一次运行）
引擎第一次运行时把 Spiders 里的start_urls全放到调度器里 - 然后引擎从调度器中取出一个链接(URL)用于接下来的抓取
- 引擎把URL封装成一个请求(Request)传给下载器
- 下载器把资源下载下来，并封装成应答包(Response)
- 爬虫解析Response
- 解析出实体（Item）,则交给实体管道进行进一步的处理
- 解析出的是链接（URL）,则把URL交给调度器等待抓取
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 scrapy
e. 下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/
Scrapy 基本使用
基本命令（cmd）：
1. scrapy startproject 项目名称
- 在当前目录中创建中创建一个项目文件（类似于Django）
2. scrapy genspider [-t template] <name> <domain>
- 创建爬虫应用
如：
scrapy gensipider -t basic oldboy oldboy.com
scrapy gensipider -t xmlfeed autohome autohome.com.cn
PS:
查看所有命令：scrapy gensipider -l
查看模板命令：scrapy gensipider -d 模板名称
3. scrapy list
- 展示爬虫应用列表
4. scrapy crawl 爬虫应用名称
- 运行单独爬虫应用
如果想在通过main.py运行，则新建main.py然后
from scrapy import cmdline
cmdline.execute("scrapy crawl chouti --nolog".split())
项目结构以及爬虫应用简介：
project_name/
scrapy.cfg
project_name/
__init__.py
items.py
pipelines.py
settings.py
spiders/
__init__.py
爬虫1.py
爬虫2.py
爬虫3.py
文件说明：
- scrapy.cfg 项目的主配置信息。（真正爬虫相关的配置信息在settings.py文件中）
- items.py 设置数据存储模板，用于结构化数据，如：Django的Model
- pipelines 数据处理行为，如：一般结构化的数据持久化
- settings.py 配置文件，如：递归的层数、并发数，延迟下载等
- spiders 爬虫目录，如：创建文件，编写爬虫规则
运行 scrapy genspider zhihu zhihu.com 后生成的.py文件
import scrapy
class ZhiHuSpider(scrapy.spiders.Spider):
name = "zhihu" # 爬虫名称 *****
allowed_domains = ["zhihu.com"] # 允许的域名
start_urls = [
"https://www.zhihu.com/", # 起始 URL
]
def parse(self, response):
# 访问起始URL并获取结果后的回调函数
# 如果在Windows里遇到编码问题，输入下面代码
import sys,os
sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gb18030')
xpath语法
nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。
如：
//book 选取所有 book 子元素，而不管它们在文档中的位置。
bookstore//book 选择属于 bookstore 元素的后代的所有 book 元素，而不管它们位于 bookstore 之下的什么位置。
/div[@id="i1"] 儿子中id="i1"的div
/div[@id="i1"]/text() 获取当前标签(div)的文本
/div[@id="i1"]/@href 获取当前标签(div)的href属性
obj.extract() 列表中的每一个对象转换成字符串，返回一个列表
obj.extract_first() 列表中的每一个对象转换成字符串，返回列表第一个元素
# a[starts-with(@属性(href), "link")，获取以link开头的
hxs = Selector(response=response).xpath('//a[starts-with(@href, "/all/hot/recent/")]')
# 也可以用正则表达式a[re:test(@href, "...")]
hxs = Selector(response=response).xpath('//a[re:test(@href, "/all/hot/recent/\d+")]')
# contains代表包含link就行
# hxs = Selector(response=response).xpath('//a[contains(@href, "link")]')
低级去重方式
我们通过爬虫获取到的 url 肯定会有重复的，所以要去重，假如我们用集合去重（低级方式）：
# 定义静态字段
visited_urls = set()
...
def parse(self, response):
for url in hxs:
if url in self.visited_urls:
print('已经存在', url)
else:
print(url)
self.visited_urls.add(url)
这样就去重了，但还有问题，当我们存储时(无论存在数据库还是内存/缓存中)，如果url的长度过大，就会导致内存的浪费，所以我们需要通过md5或者其他加密算法，将url加密，这样就固定了存储url的长度。
首先定义加密方法：
def md5(self, url):
import hashlib
obj = hashlib.md5()
obj.update(bytes(url, enco
return obj.hexdigest()
然后将上面的改成：
hxs = Selector(response=response).xpath('//a[starts-with(@href, "/all/hot/recent/")]')
for url in hxs:
md5_url = self.md5(url)
if md5_url in self.visited_urls:
print('已经存在', url)
else:
self.visited_urls.add(md5_url)
real_url = "http://dig.chouti.com/%s"%(url)
print(real_url)
运用 Request 发送请求
获取当前页的所有页码已经完成了，这时需求改了，要获取所有的页码怎么做？
获取所有页，就是从当前页跳转，然后再到跳转的页继续找，重复这个动作，这样就像是递归，而在Scrapy里，为我们提供了一个Request对象。用来请求数据（跳转就是请求新的页码）。
from scrapy.http import Request
...
else:
self.visited_urls.add(md5_url)
real_url = "http://dig.chouti.com%s"%(url)
print(real_url)
# 将新要访问的url添加到调度器
# 必须写yield，写了yield引擎才能把Request发给调度器
yield Request(url=real_url, callback=self.parse)
这样就能找到所有的页码，如果我们不想要这么多，就可以在settings.py里设置递归深度，如
DEPTH_LIMIT = 2
# DEPTH_LIMIT = 0 表示无限制
数据持久化：
Scrapy里数据的持久化是在Pipeline和item里做的。
首先在items.py里，将爬取的东西作为一个对象
class ChoutiItem(scrapy.Item):
title = scrapy.Field()
href = scrapy.Field()
然后chouti.py爬的时候存数据：
xs_item_list = Selector(response=response).xpath('//div[@id="content-list"]/div[@class="item"]')
for item in hxs_item_list:
title = item.xpath('.//a[@class="show-content color-chag"]/text()').extract_first().strip()
href = item.xpath('.//a[@class="show-content color-chag"]/@href').extract_first().strip()
# 存数据
item = ChoutiItem(title=title, href=href)
# 通过yield 发送给Pipeline
yield item
然后再Pipeline里进行持久化：
pieplines.py
class ScrapyLearnPipeline(object):
# process 处理
def process_item(self, item, spider):
# 因为所有爬虫爬的数据都放在pipeline里做持久化，所以可以根据spider.name来做区分
if spider.name == 'chouti':
# 从item里取数据通过item['xxx']
tmp = "%s\n%s\n\n"%(item['title'], item['href'])
with open('data.json', 'a') as f:
f.write(tmp)
还需要注意的是，要在settings.py中注册Pipeline：
ITEM_PIPELINES = {
'scrapy_learn.pipelines.ScrapyLearnPipeline': 300,
}
300是权重，权重大，则先持久化
去重的新方式
- 自定义类去重
- 用scrapy自带的类(RFPDupeFilter)，他是存在文件中，然后通过文件来判断的。(
from scrapy.dupefilters import RFPDupeFilter)
自定义类：
新建duplication.py
class RepeatFilter(object):
def __init__(self):
# 自定义的类可以存在内存，缓存，数据库，文件
self.visited_set = set()
@classmethod
def from_settings(cls, settings):
# 创建RepeatFilter对象 - cls()
return cls()
# 检查是否访问过
def request_seen(self, request):
if request.url in self.visited_set:
return True
self.visited_set.add(request.url)
return False
def open(self): # can return deferred
# print('open') 开始爬取
pass
def close(self, reason): # can return a deferred
# print('close') 结束爬取
pass
def log(self, request, spider): # log that a request has been filtered
# print('log....') 打印日志
pass
执行顺序是 from_settings -> __init__ -> open -> request_seen -> close
自定义类还需要更改下配置文件：
DUPEFILTER_CLASS = "day96.duplication.RepeatFilter"
// 默认是 DUPEFILTER_CLASS = "scrapy.dupefilters.RFPDupeFilter"，即scrapy自带的去重
Pipeline深入分析
Pipeline除了process_item()还有from_crawler，open_spider，close_spider方法。
from_crawler类似自定义去重类中的from_settings，也是一个类方法。
class ScrapyLearnPipeline(object):
def __init__(self,conn_str):
"""
初始化数据
"""
self.conn_str = conn_str
@classmethod
def from_crawler(cls, crawler):
"""
初始化时调用，用于创建pipeline对象，得到配置文件
还可以进行数据库配置(数据库配置都是在settings.py里进行的)
"""
conn_str = crawler.settings.get('DB') # 注意配置文件中的变量都要大写
return cls(conn_str)
def open_spider(self,spider):
"""
爬虫开始执行时，调用，如果存储用的是文件/数据库等可以在里面打开文件，这样就实现了打开一次文件，写入完后再关闭文件
"""
self.conn = open(self.conn_str, 'a')
def close_spider(self,spider):
"""
爬虫关闭时，被调用
"""
self.conn.close()
def process_item(self, item, spider):
"""
每当数据需要持久化时，就会被调用
"""
# if spider.name == 'chouti'
tpl = "%s\n%s\n\n" %(item['title'],item['href'])
self.conn.write(tpl)
# 注意如果有多个方法，一定要return，这样才能交给下一个pipeline处理
return item
# 当不需要交个下一个pipeline处理时，请务必这样写(from scrapy.exceptions import DropItem)
# raise DropItem()
Cookie问题
当爬取的网站需要登录时，需要携带请求头，请求体，Cookie。
登录流程：
访问当前页面，拿到返回的GPSD，然后带着GPSD去登录，然后服务器就会将我们的GPSD授权，授权后GPSD就可以一直用了。具体操作看实例。
实例
自动给抽屉点赞
/spiders/chouti.py
import scrapy
from scrapy.selector import Selector, HtmlXPathSelector
from scrapy.http import Request
from scrapy.http.cookies import CookieJar
class ChoutiSpider(scrapy.Spider):
name = 'chouti'
# allowed_domains = ['chouti.com/']
start_urls = ['http://dig.chouti.com/']
# 存储cookie
cookie_dict = None
def parse(self, response):
# 由于有start_urls的存在，所以会自动访问一次页面
# 创建cookie对象，现在里面还什么都没有，只是一个容器
cookie_obj = CookieJar()
# extract_cookies()需要两个参数，response和request，而reponse里包含request，这一步得到授权的cookie
cookie_obj.extract_cookies(response, response.request)
# cookie_obj._cookies 从cookie对象中拿到cookie
cookie_dict = cookie_obj._cookies
yield Request(
# 发起登录请求
url="http://dig.chouti.com/login",
method="POST",
headers={'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'},
# 请求体写法：= 和 &
body="phone=86xxx&password=xxx&oneMonth=1",
cookies=self.cookie_dict,
callback=check_login
)
def check_login(self, response):
yield Request(url='http://dig.chouti.com/', callback=self.like)
# 点赞
def like(self, response):
# 拿到赞的id列表
id_list = Selector(response).xpath('//div[@share-linkid]/@share-linkid').extract()
for nid in id_list:
# 每个赞的url
url - 'http://dig.chouti.com/link/vote?linksId=%s'%(nid)
yield Request(
url=url,
method='POST',
# 点赞需要携带cookie
cookies=self.cookie_dict,
callback=self.success
)
# 查找下一页
page_urls = Selector(response).xpath('//div[@id="dig_lcpage"]//a/@href').extract()
for page in page_urls:
url = 'http://dig.chouti.com%s'%(page)
yield Request(url=url, callback=self.like)
def success(self, response):
print(response.text)
具体源码：猛戳这里
