Scrapy框架

我就是我 2022-10-03 00:39 256阅读 0赞

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

Scrapy是基于twisted框架开发而来,twisted是一个流行的事件驱动的python网络框架.因此Scrapy使用了一种非阻塞(异步)的代码来实现并发.

执行流程:

1.引擎从spider获取初始爬虫请求

2.引擎在调度程序中调度请求,并请求下一个要爬的请求

3.调度程序将下一个请求返回到引擎

4.引擎将请求发送到下载器,并通过下载器中间件(process\_request())

5.一旦页面完成下载,下载器将生成响应(使用该页面),并将其发送到引擎,并通过下载器中间软件

6.引擎接收下载器的响应并将其发送给spider进行处理,并通过spider中间件进行处理

7.spider处理响应,并通过spider中间件向引擎返回刮掉的项目和心情求

8.引擎将已处理掉的项目发送到项目管道,然后将已处理的请求发送到计划程序,并请求可能的下一个请求进行爬取

9.该过程重复(从步骤一开始)知道调度程序不再发出请求

### 各组件极其作用 ###

1.引擎(ENGINE)

引擎负责控制系统所有组件之间的数据流,并在某些动作发生时触发事件,

2.调度器(SCHEDULER)

用来接受引擎发过来的请求,压入队列中,并在引擎再次请求时返回,可以想象成一个URL的优先级队列,由他来决定下一个要抓取的网址是什么,同时去除重复的网址

3.下载器(DOWNLOADER)

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

4.爬虫(SPIDERS)

SPIDERS使开发人员自定义的类,用来解析responses,并且提取items,或者发送新的请求

5.项目管道(ITEM PIPLINES)

在items被提取后负责处理他们,主要包括清理,验证,持久化(比如存到数据库)等操作

6下载器中间件(Downloader Middlewares)

位于Scrapy引擎和下载器之间,主要用来处理从ENGINE传到DOWNLOADER的请求request,已经从DOWNLOADER传到ENGINE的响应response

7.爬取中间件(Spider Middlewares)

位于ENGINE和SPIDERS之间,主要工作是处理SPIDERS的输入(即responses)和输出(即requests)

\#Windows平台  
1、pip3 install wheel \#安装后，便支持通过wheel文件安装软件  
，wheel文件官网：https://www.lfd.uci.edu/~gohlke/pythonlibs  
3、pip3 install lxml  
4、pip3 install pyopenssl  
5、下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/pywin32/  
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

## 常用命令 ##

1.查看帮助

scrapy -h

scrapy <command> -h

2.有两种命令,其中Projiec-only必须切到项目文件夹下才能执行,而Global的命令则不需要

## Global  commands: ##

startproject:创建项目

scrapy startproject amzon

genspider 创建爬虫程序 指定名称  限制爬取的网址

scrapy genspider amzon www.amazon.cn

settings 如果是在项目目录下,则得到的是该项目的配置

scrapy settings --get BOT\_NAME

runspider 运行一个独立的python文件,不必创建项目

scrapy runspider amzon.py

shell scrapy shell url 地址  在交互式调试,如选择器规则正确与否

scrapy shell www.taobao.com

fetch 单纯地爬取一个页面,不打开浏览器,可以拿到请求头

scrapy fetch --nolog http://www.baidu.com 不输出日志

scrapy fetch --nolog --header http://www.baidu.com不输出日志,只查看头信息

view 下载完毕后直接弹出浏览器,以此来分辨哪些数据是ajax请求

scrapy view http://www.baidu.com

version  scrapy version 查看scrapy的版本

scrapy version -v查看scrapy依赖库的版本

## Projiect-only commands: ##

必须先切到对应的目录下才能执行

crawl   运行爬虫 必须创建项目才行,确保配置文件中ROBOTSTXT\_OBEY = False

scrapy crawl amzon

check  检测项目中有无语法错误

scrapy check

list 列出项目中所包含的爬虫名

scrapy list

edit  编辑器 一般不用

parse scrapy parse url地址   --callback 回调函数

以此来验证我们的回调函数是否正确

bench  scrapy bentch压力测试

####    \# 目录结构 ####

\`\`\`python  
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项目的主配置信息,用来部署scrapy时使用,爬虫相关的配置信息在settings.py文件中

items.py 设置数据存储模板,用来结构化数据,如Django的Model

piplines:数据处理行为 如:一班结构化的数据持久化

settings.py 配置文件 如递归的层数 并发数,延迟下载等

强调:配置文件的选项必须大写否则视为无效

spiders 爬虫目录

主语一般创建爬虫文件时,以网站域名命名

Import sys,os

sys,stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gbl8030')

在pycharm中运行爬虫程序

在项目目录下新建:entrypoint.py

from scrapy.cmdline import execute

execute(\['scrapy','crawl','amzon'\])

### Spiders ###

简介

1.Spiders是由一系列类(定义了一个网址或一组网址将被爬取)组成,具体包括如何执行爬取任务并且如何从页面中提取结构化的数据

2.换句话再说,SPiders是你为了一个特定的网址或一组网址自定义爬取和解析页面行为的地方

### spiders的运作过程 ###

1.生成初始的Requests来爬取第一个urls,并且标识一个回调函数

第一个请求定义在start\_requests()方法内,默认从start\_urls列表中获得url地址来生成Request请求,默认的回调函数是parse方法.回调函数在下载完成返回response时自动触发

2.在回调函数中,解析response并且返回值

返回值可以四种:

包含解析数据的字典

Item对象

新的Request对象(新的Requests页需要指定一个回调函数)

或者是可迭代对象(包含Items或Request)

3.在回调函数中解析页面内容

通常使用Scrapy自带的Selectors,但很明显你也可以使用Beautifulsoup,lxml或其他的

4,最后针对返回的Items对象将会被持久化数据库

通过Item Pipline组件存到数据库:或者导出到不同的文件

spiders模板类

\`\`\`python  
Spider 基础的爬虫 也是我们呢最常用的爬虫 不会对response 进行任何解析  
直接传给回调函数

SitemapSpider 站点信息爬虫 对于需要seo优化的网站通常会在网站根目录下创建  
站点地图文件  
其中列出网站所有链接地址，然后将该文件提交给搜索引擎，搜索引擎收录后，  
会查看其中的信息，例如最后跟新时间等，以便于搜索引擎的爬虫更有效的爬取你的网页

CrawlSpider  
CrawlSpider类定义了一些规则(rule)来提供跟进link的机制，  
从爬取的网页中获取link并继续爬取。

固定格式爬虫  
CSVFeedSpider 回调函数parse\_row包含一个row用于直接提取一行内容  
XMLFeedSpider，回调函数parse\_node包含一个node表示一个节点

\`\`\`

\#\#\#\# Spider的详细使用

这是最简单的spider类，任何其他的spider类都需要继承它（包含你自己定义的）。

该类不提供任何特殊的功能，它仅提供了一个默认的start\_requests方法  
默认从start\_urls中读取url地址发送requests请求，并且默认parse作为回调函数

\`\`\`python  
class AmazonSpider(scrapy.Spider):  
name = 'amazon'  
allowed\_domains = \['www.amazon.cn'\]  
start\_urls = \['http://www.amazon.cn/'\]  
  
custom\_settings = \{  
'BOT\_NAME' : 'Egon\_Spider\_Amazon',  
'REQUEST\_HEADERS' : \{  
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,\*/\*;q=0.8',  
'Accept-Language': 'en',  
\}  
\}  
def parse(self, response):  
pass  
\`\`\`

\`\`\`python  
\#1、name = 'amazon'  
定义爬虫名，scrapy会根据该值定位爬虫程序  
所以它必须要有且必须唯一（In Python 2 this must be ASCII only.）

\#2、allowed\_domains = \['www.amazon.cn'\]  
定义允许爬取的域名，如果OffsiteMiddleware启动（默认就启动），  
那么不属于该列表的域名及其子域名都不允许爬取  
如果爬取的网址为：https://www.example.com/1.html，那就添加'example.com'到列表.

\#3、start\_urls = \['http://www.amazon.cn/'\]  
如果没有指定start\_requests，就从该列表中读取url来生成第一个请求

\#4、custom\_settings  
值为一个字典，定义一些配置信息，在运行爬虫程序时，这些配置会覆盖项目级别的配置  
所以custom\_settings必须被定义成一个类属性  
  
\#5、settings  
通过self.settings\['配置项的名字'\]可以访问settings.py中的配置，  
如果自己定义了custom\_settings还是以自己的为准

\#6、logger  
日志名默认为spider的名字  
self.logger.debug('=============>%s' %self.settings\['BOT\_NAME'\])

\#7、start\_requests()  
该方法用来发起第一个Requests请求，且必须返回一个可迭代的对象。  
它在爬虫程序打开时就被Scrapy调用，Scrapy只调用它一次。  
默认从start\_urls里取出每个url来生成Request(url, dont\_filter=True)  
  
\#8、parse(response)  
这是默认的回调函数，所有的回调函数必须返回  
an iterable of Request and/or dicts or Item objects.

\#9、closed(reason)  
爬虫程序结束时自动触发  
\`\`\`

\#\# 自定义去重规则

在爬取网页的过程中可能会爬到一些重复的网页，这就需要制定去重规则了  
，默认情况下scrapy就会自动帮我们去除

\`\`\`python  
去重规则应该多个爬虫共享的，但凡一个爬虫爬取了，其他都不要爬了，实现方式如下

\#方法一：  
1、新增类属性  
visited=set() \#类属性

2、回调函数parse方法内：  
def parse(self, response):  
if response.url in self.visited:  
return None  
.......

self.visited.add(response.url)

\#方法一改进：针对url可能过长，所以我们存放url的hash值  
def parse(self, response):  
url=md5(response.request.url)  
if url in self.visited:  
return None  
.......

self.visited.add(url)

\#方法二：Scrapy自带去重功能  
配置文件：  
DUPEFILTER\_CLASS = 'scrapy.dupefilter.RFPDupeFilter'  
\#默认的去重规则帮我们去重，去重规则在内存中  
DUPEFILTER\_DEBUG = False \# 是否记录所有重复请求 默认为第一个重复请求  
JOBDIR = "保存范文记录的日志路径，如：/root/"  
\# 最终路径为 /root/requests.seen，去重规则放文件中

scrapy自带去重规则默认为RFPDupeFilter，只需要我们指定  
Request(...,dont\_filter=False) ，如果dont\_filter=True则告诉Scrapy这个URL不参与去重。

\#方法三：  
我们也可以仿照RFPDupeFilter自定义去重规则，

from scrapy.dupefilter import RFPDupeFilter，看源码，仿照BaseDupeFilter

\#步骤一：在项目目录下自定义去重文件dup.py  
class UrlFilter(object):  
def \_\_init\_\_(self):  
self.visited = set() \#或者放到数据库

@classmethod  
def from\_settings(cls, settings):  
return cls()

def request\_seen(self, request):  
if request.url in self.visited:  
return True  
self.visited.add(request.url)

def open(self): \# can return deferred  
pass

def close(self, reason): \# can return a deferred  
pass

def log(self, request, spider): \# log that a request has been filtered  
pass

\#步骤二：配置文件settings.py：  
DUPEFILTER\_CLASS = '项目名.dup.UrlFilter'

\# 源码分析：  
from scrapy.core.scheduler import Scheduler  
见Scheduler下的enqueue\_request方法：self.df.request\_seen(request)  
\`\`\`

\#\# 数据解析

\`\`\`python  
response常用属性与方法  
text 获取文本  
body 获取二进制  
css() css选择器  
xpath() xptah解析

css与xpath返回值都是selector类型

selector常用方法  
extract 提取字符串形式数据  
extract\_first 提取第一个  
css() 在当前文档上继续查找其他元素 返回selector类型  
xpath()在当前文档上继续查找其他元素 返回selector类型  
\`\`\`

\#\# 数据持久化

scrapy中使用item来作为数据模型，pipeline作为数据持久化组件

\#\#\#\#\# items.py

找到items文件 为itme类添加所需的属性

\`\`\`python  
class PicItem(scrapy.Item):  
\# define the fields for your item here like:  
\# name = scrapy.Field()  
title = scrapy.Field()  
url = scrapy.Field()  
\`\`\`

\#\#\#\#\# pipelines.py

一个pipeline应该具备以下几个方法

\`\`\`python  
class MyPipeline():  
def process\_item(self, item, spider):  
"""  
负责将一个Item进行持久化  
返回值将继续传递给下一个pipeline（如果有），即便是None  
"""  
return item  
  
def open\_spider(self, spider):  
"""  
爬虫程序启动时执行该函数  
用于初始化操作例如连接数据库  
"""  
pass

def close\_spider(self, spider):  
"""  
爬虫程序关闭时执行该函数  
用于初清理操作例如关闭数据库  
"""  
pass  
  
\# 创建pipeline 会自动查看是否存在该方法如果存在则直接调用 用于获取一个pipline  
\# crawler中的settings属性可以获取配置文件信息  
@classmethod  
def from\_crawler(cls, crawler):  
\# 从配置文件中读取数据来创建pipline  
def get(key):  
return crawler.settings.get(key)  
return cls(get("HOST"),get("USER"),get("PWD"),get("DB"))  
\`\`\`

\#\#\#\#\# 代码写完后需要到配置文件中添加对应的配置项

\`\`\`python  
\#数字表示优先级，数值越小优先级越高  
ITEM\_PIPELINES = \{  
"name.pipelines.MysqlPipeline":10,  
"name.pipelines.JsonPipeline":20  
\}  
\`\`\`

\#\#\#\#\# 一个基于文件的实例

\`\`\`python  
class JsonPipeline():  
def \_\_init\_\_(self):  
self.json\_data = \[\]  
\# 在这里处理item的持久化  
def process\_item(self, item, spider):  
self.json\_data.append(dict(item))  
return item

def open\_spider(self, spider):  
pass

def close\_spider(self, spider):  
with open("pics.json","wt") as f:  
json.dump(self.json\_data,f)  
\`\`\`

\#\#\#\#\# 中断pipeline的继续调用

process\_item函数一旦有返回值就会继续执行后续的pipeline，即时返回None，  
可以是使用以下方法中断

\`\`\`python  
\#导入 DropItem类  
from scrapy.exceptions import DropItem  
\# 在process\_item中抛出异常  
def process\_item(self, item, spider):  
raise DropItem  
\`\`\`

\#\# 下载器中间件

下载器主要负责从网络上下载数据，下载器中间件用于对请求与响应进行处理

例如：设置cookie，header，添加代理等等

\`\`\`python  
class DownMiddleware1(object):  
def process\_request(self, request, spider):  
"""  
该方法在下载器发起请求前执行  
:param request:  
:param spider:  
:return:  
None,继续后续中间件去下载；  
Response对象，停止process\_request的执行，开始执行process\_response  
Request对象，停止中间件的执行，将Request重新调度器  
raise IgnoreRequest异常，停止process\_request的执行，  
开始执行process\_exception  
"""  
pass

def process\_response(self, request, response, spider):  
"""  
数据下载完成，返回spider前执行  
:param response:  
:param result:  
:param spider:  
:return:  
Response 对象：转交给其他中间件process\_response  
Request 对象：停止中间件，request会被重新调度下载  
raise IgnoreRequest 异常：调用Request.errback  
"""  
print('response1')  
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将会被重新调用下载  
"""  
return None  
\`\`\`

\#\#\#\#\# 代码写完后需要到配置文件中添加对应的配置项

\`\`\`python  
DOWNLOADER\_MIDDLEWARES = \{  
'name.middlewares.TDownloaderMiddleware': 100,  
\}  
需要注意的是优先级一定要比系统的高，因为scrapy自己有个proxy中间件  
\`\`\`

\#\#\#\# ip代理池

首先需要明确代理池的原理，从网页上爬取免费的代理地址数据，  
在请求时，如果对方服务器，限制访问IP，就从代理池中获取代理地址重新访问

网络上有很多线程的开源代理池，这里以IPProxyPool 为例

下载地址：https://github.com/qiyeboy/IPProxyPool

1.下载代理池

2.安装依赖

在代代理池目录中找到requirements.txt 复制其路径 执行以下命令

pip3 install -r 文件路径

3.下载webpy https://codeload.github.com/webpy/webpy/zip/py3

安装webpy

切换目录到webpy文件夹中执行以下命令

python setup.py install

4.运行IPProxy.py文件开始爬取ip

执行过程可能报错，根据错误信息安装对应的模块即可

5.在项目中请求代理池的接口获取代理ip

\`\`\`python  
import requests,random  
ips = None  
def get\_proxy():  
global ips  
if not ips:  
ips = requests.get("http://127.0.0.1:8001/").json()  
a = random.choice(ips)  
return "http://"+a\[0\]+":"+str(a\[1\])

def delete\_ip(ip):  
ip = ip.strip("http://").split(":")\[0\]  
res = requests.get("http://127.0.0.1:8001/delete?ip="+ip).json()  
print(res)

if \_\_name\_\_ == '\_\_main\_\_':  
\# print(get\_proxy())  
\#delete\_ip("http://60.184.34.232:9999")  
\`\`\`

转载于:https://www.cnblogs.com/suncunxu/p/10719963.html