scrapy架构流程
• Scrapy,Python开发的一个快速、高层次的屏幕抓取和web抓取框架,用
于抓取web站点并从页面中提取结构化的数据。
• Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。
它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版
本又提供了web2.0爬虫的支持。
• Scrap,是碎片的意思,这个Python的爬虫框架叫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引擎发送到调度的请求和响应。
使用
# 爬取的步骤
- 确定url地址;
- 获取页面信息;(urllib, requests);
- 解析页面提取需要的数据; (正则表达式, bs4, xpath)
- 保存到本地(csv, json, pymysql, redis);
- 清洗数据(删除不必要的内容 -----正则表达式);
- 分析数据(词云wordcloud + jieba)
有没有用到多线程? -----
获取页面信息每个爬虫都会使用, 重复去写----
设置头部信息 ---- user-agent, proxy....
# 流程分析:
- 确定url地址:http://www.imooc.com/course/list;(spider)
- 获取页面信息;(urllib, requests); ---(scrapy中我们不要处理)---(Downloader)
- 解析页面提取需要的数据; (正则表达式, bs4, xpath)---: (spider)
课程链接, 课程的图片url, 课程的名称, 学习人数, 课程描述
- 保存到本地(csv, json, pymysql, redis); ----(pipeline)
# 环境
- Scrapy 1.6.0
# 实现步骤:
1. 工程创建
scrapy startproject mySpider
cd mySpider
tree
├── mySpider
│ ├── __init__.py
│ ├── items.py # 提取的数据信息
│ ├── middlewares.py # 中间键
│ ├── pipelines.py # 管道, 如何存储数据
│ ├── __pycache__
│ ├── settings.py # 设置信息
│ └── spiders # 爬虫(解析页面的信息)
│ ├── __init__.py
│ └── __pycache__
└── scrapy.cfg
2. 创建一个爬虫
scrapy genspider mooc "www.imooc.com"
cd mySpider/spiders/
vim mooc.py
# start_url
3. 定义爬取的items内容
class CourseItem(scrapy.Item):
# 课程标题
title = scrapy.Field()
# 课程的url地址
url = scrapy.Field()
# 课程图片url地址
image_url = scrapy.Field()
# 课程的描述
introduction = scrapy.Field()
# 学习人数
student = scrapy.Field()
# 4. 编写spider代码, 解析
新建项目
明确目标
1.在items.py中定义变量
用于保存爬取到的数据,类似于python中的字典,提供了额外的一些保护
import scrapy
class CourseItem(scrapy.Item):
# Item对象是一个简单容器, 保存爬取到的数据, 类似于字典的操作;
# 实例化对象: course = CourseItem()
# course['title'] = "语文"
# course['title']
# course.keys()
# course.values()
# course.items()
# define the fields for your item here like:
# name = scrapy.Field()
# 课程链接, 课程的图片url, 课程的名称, 学习人数, 课程描述
# 课程标题
title = scrapy.Field()
# 课程的url地址
url = scrapy.Field()
# 课程图片url地址
image_url = scrapy.Field()
# 课程的描述
introduction = scrapy.Field()
# 学习人数
student = scrapy.Field()
制作爬虫
2.定义解析方法
name = “” :这个爬虫的识别名称,必须是唯一的,在不同的爬虫必须定义不同的名字。
allow_domains = [] 是搜索的域名范围,也就是爬虫的约束区域,规定爬虫只爬取这个域名下的网页,不存在的URL会被忽略。
start_urls = () :爬取的URL元祖/列表。爬虫从这里开始抓取数据,所以,第一次下载的数据将会从这些urls开始。其他子URL将会从这些起始URL中继承性生成。
parse(self, response) :解析的方法,每个初始URL完成下载后将被调用,调用的时候传入从每一个URL传回的Response对象来作为唯一参数,主要作用如下:
负责解析返回的网页数据(response.body),提取结构化数据(生成item)
生成需要下一页的URL请求
** 用来检测代码是否达到指定位置, 并用来调试并解析页面信息;
from scrapy.shell import inspect_response
inspect_response(response, self)**
import scrapy
from mySpider.items import CourseItem
class MoocSpider(scrapy.Spider):
# name: 用于区别爬虫, 必须是唯一的;
name = 'mooc'
# 允许爬取的域名;其他网站的页面直接跳过;
allowed_domains = ['www.imooc.com', 'img3.mukewang.com']
# 爬虫开启时第一个放入调度器的url地址;
start_urls = ['http://www.imooc.com/course/list']
# 被调用时, 每个初始url完成下载后, 返回一个响应对象,
# 负责将响应的数据分析, 提取需要的数据items以及生成下一步需要处理的url地址请求;
def parse(self, response):
# # 用来检测代码是否达到指定位置, 并用来调试并解析页面信息;
# from scrapy.shell import inspect_response
# inspect_response(response, self)
# 1). 实例化对象, CourseItem
course = CourseItem()
# 分析响应的内容
# scrapy分析页面使用的是xpath语法
# 2). 获取每个课程的信息: <div class="course-card-container">
courseDetails = response.xpath('//div[@class="course-card-container"]')
for courseDetail in courseDetails:
# 课程的名称:
# "htmlxxxx"
# 爬取新的网站, Scrapy里面进行调试(parse命令logging)
course['title'] = courseDetail.xpath('.//h3[@class="course-card-name"]/text()').extract()[0]
# 学习人数
course['student'] = courseDetail.xpath('.//span/text()').extract()[1]
# 课程描述:
course['introduction'] = courseDetail.xpath(".//p[@class='course-card-desc']/text()").extract()[0]
# 课程链接, h获取/learn/9 ====》 http://www.imooc.com/learn/9
course['url'] = "http://www.imooc.com" + courseDetail.xpath('.//a/@href').extract()[0]
# 课程的图片url:
course['image_url'] = 'http:' + courseDetail.xpath('.//img/@src').extract()[0]
yield course
储存数据
在pipelines.py文件中定义存储方式
from scrapy.pipelines.images import ImagesPipeline
from teach.day29.mySpider.mySpider.settings import MOOCFilename
class MyspiderPipeline(object):
"""将爬取的信息保存为Json格式"""
def __init__(self):
self.f = open(MOOCFilename, 'w')
def process_item(self, item, spider):
# 默认传过来的item是json格式
import json
# 读取item中的数据, 并转成json格式;
line = json.dumps(dict(item), ensure_ascii=False, indent=4)
self.f.write(line + '\n')
# 一定要加, 返回给调度为器;
return item
def open_spider(self, spider):
"""开启爬虫时执行的函数"""
pass
def close_spider(self, spider):
"""当爬虫全部爬取结束的时候执行的函数"""
self.f.close()
import scrapy
# scrapy框架里面,
class ImagePipeline(ImagesPipeline):
def get_media_requests(self, item, info):
# 返回一个request请求, 包含图片的url地址
yield scrapy.Request(item['image_url'])
# 当下载请求完成后执行的函数/方法
def item_completed(self, results, item, info):
# open('mooc.log', 'w').write(results)
# 获取下载的地址
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise Exception("不包含图片")
else:
return item
开启管道
MOOCFilename = "mooc.txt"
ITEM_PIPELINES = {
# 管道的位置: 优先级, 0~1000, 数字越小, 优先级越高;
'mySpider.pipelines.MyspiderPipeline': 300,
'mySpider.pipelines.CsvPipeline': 400,
'mySpider.pipelines.MysqlPipeline': 500,
'mySpider.pipelines.ImagePipeline': 200,
}
IMAGES_STORE = '/root/PycharmProjects/day29/mySpider/img'
获取下一页再执行parse函数
import scrapy
from mySpider.items import CourseItem
class MoocSpider(scrapy.Spider):
name = 'mooc'
allowed_domains = ['www.imooc.com']
start_urls = ['http://www.imooc.com/course/list']
def parse(self, response):
#断点调试
# from scrapy.shell import inspect_response
# inspect_response(response,self)
courseDetails = response.xpath('//div[@class="course-card-container"]')
for courseDetail in courseDetails:
course = CourseItem()
course['title'] = courseDetail.xpath('.//h3[@class="course-card-name"]/text()').extract()[0]
course['student'] = courseDetail.xpath('.//span/text()').extract()[1]
course['introduction'] = courseDetail.xpath('.//p[@class="course-card-desc"]/text()').extract()[0]
course['url'] = 'http://www.imooc.com'+courseDetail.xpath('.//a/@href').extract()[0]
course['image_url'] = 'http:'+courseDetail.xpath('.//img/@src').extract()[0]
yield course
#
url = response.xpath('.//a[contains(text(),"下一页")]/@href')[0].extract()
if url:
page = 'http://www.imooc.com'+url
yield scrapy.Request(page,callback=self.parse)
个人博客整理
解析
import scrapy
from scrapy.shell import inspect_response
from mySpider.items import csdnItem
from mySpider.settings import CsdnPage
class CsdnSpider(scrapy.Spider):
name = 'csdn'
allowed_domains = ['csdn.net']
start_urls = [
'https://blog.csdn.net/mkgdjing',
# 'https://blog.csdn.net/gf_lvah',
]
def parse(self, response):
# 类似于字典的对象
boxs = response.xpath('//div[@class="article-item-box csdn-tracking-statistics"]')
for box in boxs:
# 打印仅为了测试;
# ************将item对象实例化在for循环里面, 否则每次会覆盖之前item的信息;*******
item = csdnItem()
item['title'] = box.xpath('./h4/a/text()')[1].extract().strip()
item['url'] = box.xpath('./h4/a/@href')[0].extract()
# print("1. *****************", item['title'])
yield scrapy.Request(item['url'], meta={'item': item}, callback=self.parse_article)
for page in range(2, 3):
url = "https://blog.csdn.net/mkgdjing/article/list/%s" %(page)
yield scrapy.Request(url, callback=self.parse)
def parse_article(self, response):
item = response.request.meta['item']
# 打印仅仅为了测试:出现问题的部分.
# print("2.************************", item['title'])
# inspect_response(response, self)
content = response.xpath('//div[@id="article_content"]').extract()[0]
item['content'] = 'aaa'
yield item
管道
class MyspiderPipeline(object):
def process_item(self, item, spider):
return item
class CsvPipeline(object):
"""将爬取的信息保存为csv格式"""
def __init__(self):
self.f = open('csdn.csv', 'w')
def process_item(self, item, spider):
# xxxx:xxxxx:xxxx
item = dict(item)
self.f.write("{0}:{1}:{2}\n".format(item['title'], item['url'], item['content']))
# 一定要加, 返回给调度为器;
return item
def open_spider(self, spider):
"""开启爬虫时执行的函数"""
pass
def close_spider(self, spider):
"""当爬虫全部爬取结束的时候执行的函数"""
self.f.close()
setting开启管道
scrapy反爬虫
策略一:设置download_delay
-
作用:设置下载的等待时间,大规模集中的访问对服务器的影响最大,相当与短时间中增大服务器负载。
-
缺点: 下载等待时间长,不能满足段时间大规模抓取的要求,太短则大大增加了被ban的几率
策略二:禁止cookies
- Cookie,有时也用其复数形式 Cookies,指某些网站为了辨别用户身份、进行 session
跟踪而储存在用户本地终端上的数据(通常经过加密)。 - 作用: 禁止cookies也就防止了可能使用cookies识别爬虫轨迹的网站得逞。
- 实现: COOKIES_ENABLES=False
策略三:使用user agent池(拓展: 用户代理中间件)
- 为什么使用? scrapy本身是使用Scrapy/0.22.2来表明自己身份的。这也就暴露了自己是爬虫的信息。
- user agent,是指包含浏览器信息、操作系统信息等的一个字符串,也称之为一种特殊的网络协议。服务
器通过它判断当前访问对象是浏览器、邮件客户端还是网络爬虫。
策略四:使用代理IP中间件
- web server应对爬虫的策略之一就是直接将你的IP或者是整个IP段都封掉禁止访问,
这时候,当IP封掉后,转换到其他的IP继续访问即可。
策略五: 分布式爬虫Scrapy+Redis+MySQL # 多进程
Scrapy-Redis则是一个基于Redis的Scrapy分布式组件。
它利用Redis对用于爬取的请求(Requests)进行存储和调度(Schedule),
并对爬取产生rapy一些比较关键的代码,将scrapy变成一个可以在多个主
机上同时运行的分布式爬虫。
setting.py中设置:
1. 设置DOWNLOAD_DELAY = 3,
设置下载的等待时间;每下载一个页面, 等待xxx秒。
2. 禁止cookie信息;
Disable cookies (enabled by default)
COOKIES_ENABLED = False
3. 设置用户代理
USER_AGENT = ‘Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0’
4. 设置User-Agent的中间键
5. 设置代理IP的中间键
Use-Agent:
class UserAgentMiddleware(object):
def __init__(self):
self.user_agent = [
'Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0',
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 "
]
def process_request(self, request, spider):
ua = random.choice(self.user_agent)
if ua:
# 此行仅为了测试, 真实场景不要打印, 会影响爬虫的效率
print("当前使用的用户代理: %s" %(ua))
request.headers.setdefault('User-Agent', ua)
代理ip:
class ProxiesMiddleware(object):
# 留下练习:
# - 1). 从西刺代理IP网站获取所有的代理IP并存储到mysql/redis;
def __init__(self):
# 2). 连接redis/mysql数据库;
self.proxies = [
'http://116.209.54.221:9999',
"https://111.177.183.212:9999"
]
def process_request(self, request, spider):
"""当发起请求"""
# 3). 从数据库里面随即获取一个代理IP;
proxy = random.choice(self.proxies)
if proxy:
# 此行仅为了测试, 真实场景不要打印, 会影响爬虫的效率
# print("当前使用的代理IP: %s" %(proxy))
request.meta['proxy'] = proxy