1 scrapy介绍
# 前面学的都是模块，做专业的爬虫，可以使用框架 (django:web) scrapy:爬虫框架
-做爬虫用的东西，都封装好了，只需要在固定的位置写固定的代码即可
# scrapy 号称爬虫界的djagno
-django 大而全，做web相关的它都用
-scrapy 大而全，做爬虫的，它都用
# 介绍
Scrapy一个开源和协作的框架，其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的，使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。但目前Scrapy的用途十分广泛，可用于如数据挖掘、监测和自动化测试等领域，也可以应用在获取API所返回的数据或者通用的网络爬虫
# 安装 scrapy
-mac，linux：
pip3 install scrapy
-win：看人品
-pip3 install scrapy
-人品不好：
1、pip3 install wheel #安装后，便支持通过wheel文件安装软件 xx.whl
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
# 释放出scrapy 可执行文件
-以后使用这个创建爬虫项目 ---》django-admin创建django项目
# 创建爬虫项目
scrapy startproject myfirstscrapy
# 创建爬虫 [django创建app]
scrapy genspider cnblogs www.cnblogs.com
# 启动爬虫
scrapy crawl cnblogs --nolog
# pycharm中运行
新建run.py
from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'cnblogs','--nolog'])
2 scrapy架构介绍
![]()
# 引擎(EGINE)
引擎负责控制系统所有组件之间的数据流，并在某些动作发生时触发事件。有关详细信息，请参见上面的数据流部分。
# 调度器(SCHEDULER)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
# 下载器(DOWLOADER)
用于下载网页内容, 并将网页内容返回给EGINE，下载器是建立在twisted这个高效的异步模型上的
# 爬虫(SPIDERS)--->在这里写代码
SPIDERS是开发人员自定义的类，用来解析responses，并且提取items，或者发送新的请求
# 项目管道(ITEM PIPLINES)
在items被提取后负责处理它们，主要包括清理、验证、持久化（比如存到数据库）等操作
# 下载器中间件(Downloader Middlewares)
位于Scrapy引擎和下载器之间，主要用来处理从EGINE传到DOWLOADER的请求request，已经从DOWNLOADER传到EGINE的响应response，你可用该中间件做以下几件事：设置请求头，设置cookie，使用代理，集成selenium
# 爬虫中间件(Spider Middlewares)
位于EGINE和SPIDERS之间，主要工作是处理SPIDERS的输入（即responses）和输出（即requests）
3 scrapy解析数据
1 response对象有css方法和xpath方法
-css中写css选择器
-xpath中写xpath选择
2 重点1：
-xpath取文本内容
'.//a[contains(@class,"link-title")]/text()'
-xpath取属性
'.//a[contains(@class,"link-title")]/@href'
-css取文本
'a.link-title::text'
-css取属性
'img.image-scale::attr(src)'
3 重点2：
.extract_first() 取一个
.extract() 取所有
class CnblogsSpider(scrapy.Spider):
name = 'cnblogs'
allowed_domains = ['www.cnblogs.com']
start_urls = ['http://www.cnblogs.com/']
def parse(self, response):
# response类似于requests模块的response对象
# print(response.text)
# 返回的数据，解析数据：
# 方式一：使用bs4(不用了)
# soup=BeautifulSoup(response.text,'lxml')
# article_list=soup.find_all(class_='post-item')
# for article in article_list:
# title_name=article.find(name='a',class_='post-item-title').text
# print(title_name)
# 方式二：scrapy自带的解析（css，xpath）
# css解析
# article_list = response.css('article.post-item')
# for article in article_list:
# title_name = article.css('section>div>a::text').extract_first()
# author_img = article.css('p.post-item-summary>a>img::attr(src)').extract_first()
# desc_list = article.css('p.post-item-summary::text').extract()
# desc = desc_list[0].replace('\n', '').replace(' ', '')
# if not desc:
# desc = desc_list[1].replace('\n', '').replace(' ', '')
#
# author_name = article.css('section>footer>a>span::text').extract_first()
# article_date = article.css('section>footer>span>span::text').extract_first()
# # 文章详情内容，因为在下一页，先不着急
# print('''
# 文章标题：%s
# 作者头像：%s
# 摘要：%s
# 作者名字：%s
# 发布日期：%s
# ''' % (title_name, author_img, desc, author_name, article_date))
#xpath选择器
article_list = response.xpath('//article[contains(@class,"post-item")]')
for article in article_list:
title_name = article.xpath('./section/div/a/text()').extract_first()
author_img = article.xpath('./section/div/p//img/@src').extract_first()
desc_list = article.xpath('./section/div/p/text()').extract()
desc = desc_list[0].replace('\n', '').replace(' ', '')
if not desc:
desc = desc_list[1].replace('\n', '').replace(' ', '')
author_name = article.xpath('./section/footer/a/span/text()').extract_first()
article_date = article.xpath('./section/footer/span/span/text()').extract_first()
# 文章详情内容，因为在下一页，先不着急
print('''
文章标题：%s
作者头像：%s
摘要：%s
作者名字：%s
发布日期：%s
''' % (title_name,author_img,desc,author_name,article_date))
4 settings相关配置，提高爬取效率
#1 是否遵循爬虫协议
ROBOTSTXT_OBEY = False
#2 LOG_LEVEL 日志级别
LOG_LEVEL='ERROR' # 报错如果不打印日志，在控制台看不到错误
# 3 USER_AGENT
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'
# 4 DEFAULT_REQUEST_HEADERS 默认请求头
#DEFAULT_REQUEST_HEADERS = {
# 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
# 'Accept-Language': 'en',
#}
# 5 SPIDER_MIDDLEWARES 爬虫中间件
#SPIDER_MIDDLEWARES = {
# 'cnblogs.middlewares.CnblogsSpiderMiddleware': 543,
#}
# 6 DOWNLOADER_MIDDLEWARES 下载中间件
#DOWNLOADER_MIDDLEWARES = {
# 'cnblogs.middlewares.CnblogsDownloaderMiddleware': 543,
#}
# 7 ITEM_PIPELINES 持久化配置
#ITEM_PIPELINES = {
# 'cnblogs.pipelines.CnblogsPipeline': 300,
#}
#8 爬虫项目名字
BOT_NAME = 'myfirstscrapy'
#9 指定爬虫类的py文件的位置
SPIDER_MODULES = ['myfirstscrapy.spiders']
NEWSPIDER_MODULE = 'myfirstscrapy.spiders'
4.1 增加爬虫的爬取效率
#1 增加并发：默认16
默认scrapy开启的并发线程为32个，可以适当进行增加。在settings配置文件中修改
CONCURRENT_REQUESTS = 100
值为100,并发设置成了为100。
#2 降低日志级别：
在运行scrapy时，会有大量日志信息的输出，为了减少CPU的使用率。可以设置log输出信息为INFO或者ERROR即可。在配置文件中编写：
LOG_LEVEL = 'INFO'
# 3 禁止cookie：
如果不是真的需要cookie，则在scrapy爬取数据时可以禁止cookie从而减少CPU的使用率，提升爬取效率。在配置文件中编写：
COOKIES_ENABLED = False
# 4 禁止重试：
对失败的HTTP进行重新请求（重试）会减慢爬取速度，因此可以禁止重试。在配置文件中编写：
RETRY_ENABLED = False
# 5 减少下载超时：
如果对一个非常慢的链接进行爬取，减少下载超时可以能让卡住的链接快速被放弃，从而提升效率。在配置文件中进行编写：
DOWNLOAD_TIMEOUT = 10 超时时间为10s
5 持久化方案
# 保存到硬盘上---》持久化
# 两种方案，第二种常用
-第一种：了解
-解析函数中parse，要return [{},{},{}]
-scrapy crawl cnblogs -o 文件名(json,pickle,csv结尾)
-方案二：使用pipline 常用的，管道形式，可以同时存到多个位置的
-1 在items.py中写一个类[相当于写django的表模型]，继承scrapy.Item
-2 在类中写属性，写字段，所有字段都是scrapy.Field类型
title = scrapy.Field()
-3 在爬虫中导入类，实例化得到对象，把要保存的数据放到对象中
item['title'] = title 【不要使用. 放】
解析类中 yield item
-4 修改配置文件，指定pipline，数字表示优先级，越小越大
ITEM_PIPELINES = {
'crawl_cnblogs.pipelines.CrawlCnblogsPipeline': 300,
}
-5 写一个pipline：CrawlCnblogsPipeline
-open_spider:数据初始化，打开文件，打开数据库链接
-process_item：真正存储的地方
-一定不要忘了return item，交给后续的pipline继续使用
-close_spider：销毁资源，关闭文件，关闭数据库链接
6 全站爬取cnblogs文章
# 第一页爬完后，要保存的数据已经保存了
#接下来要做两个事：
1 继续爬取下一页：解析出下一页的地址，包装成request对象
2 继续爬取详情页：解析出详情页地址，包装成request对象
# 现在在这不能保存了，因为数据不全，缺了文章详情，把文章详情加入后，再一次性保存
6.1 request和response对象传递参数
# Request创建：在parse中，for循环中，创建Request对象时，传入meta
yield Request(url=url, callback=self.detail_parse,meta={'item':item})
# Response对象：detail_parse中，通过response取出meta取出item，把文章详情写入
yield item
6.2 解析下一页并继续爬取
import scrapy
from bs4 import BeautifulSoup
from myfirstscrapy.items import CnblogsItem
from scrapy import Request
# from scrapy.http.request import Request
class CnblogsSpider(scrapy.Spider):
name = 'cnblogs'
allowed_domains = ['www.cnblogs.com']
start_urls = ['http://www.cnblogs.com/']
def parse(self, response):
# item = CnblogsItem() # 外面定义，会有问题
article_list = response.xpath('//article[contains(@class,"post-item")]')
for article in article_list:
item = CnblogsItem() # 定义在for内部，每次都是一个新对象
title_name = article.xpath('./section/div/a/text()').extract_first()
author_img = article.xpath('./section/div/p//img/@src').extract_first()
desc_list = article.xpath('./section/div/p/text()').extract()
desc = desc_list[0].replace('\n', '').replace(' ', '')
if not desc:
desc = desc_list[1].replace('\n', '').replace(' ', '')
author_name = article.xpath('./section/footer/a/span/text()').extract_first()
article_date = article.xpath('./section/footer/span/span/text()').extract_first()
url = article.xpath('./section/div/a/@href').extract_first()
# 文章详情内容，因为在下一页，先不着急
item['title_name'] = title_name
item['author_img'] = author_img
item['desc'] = desc
item['author_name'] = author_name
item['article_date'] = article_date
item['url'] = url
# print(url)
# 现在不存了，因为数据不全，等全了以后再存，继续爬取，就要创建Request对象
# 详情页面，使用self.detail_parse解析
yield Request(url=url, callback=self.detail_parse,meta={'item':item})
# 解析出下一页地址
# css
next_url = 'https://www.cnblogs.com' + response.css('div.pager>a:last-child::attr(href)').extract_first()
print(next_url)
yield Request(url=next_url, callback=self.parse)
def detail_parse(self, response):
# print(len(response.text))
item=response.meta.get('item')
# 解析详情
article_content=response.css('div.post').extract_first()
# print(article_content)
# print('===================')
# 把详情，写入当前meta中得item中
item['article_content']=str(article_content)
yield item
7 爬虫和下载中间件
# scrapy的所有中间件都写在middlewares.py中，跟djagno非常像，做一些拦截
# 爬虫中间件（用的很少，了解即可）
MyfirstscrapySpiderMiddleware
def process_spider_input(self, response, spider): # 进入爬虫会执行它
def process_spider_output(self, response, result, spider): #从爬虫出来会执行它
def process_spider_exception(self, response, exception, spider):#出了异常会执行
def process_start_requests(self, start_requests, spider):#第一次爬取执行
def spider_opened(self, spider): #爬虫开启执行
# 下载中间件
MyfirstscrapyDownloaderMiddleware
def process_request(self, request, spider): # request对象从引擎进入到下载器会执行
def process_response(self, request, response, spider):# response对象从下载器进入到引擎会执行
def process_exception(self, request, exception, spider):#出异常执行它
def spider_opened(self, spider): #爬虫开启执行它
#重点：process_request，process_response
# 下载中间件的process_request
-返回值：
- return None: 继续执行下面的中间件的process_request
- return a Response object： 不进入下载中间件了，直接返回给引擎，引擎把它通过6给爬虫
- return a Request object：不进入中间件了，直接返回给引擎，引擎把它放到调度器中
- raise IgnoreRequest: process_exception() 抛异常，会执行process_exception
# 下载中间件的process_response
-返回值：
- return a Response object：正常，会进入到引擎，引擎把它给爬虫
- return a Request object： 会进入到引擎，引擎把它放到调度器中，等待下次爬取
- raise IgnoreRequest 会执行process_exception
8 加代理，cookie，header，加入selenium
8.1 加代理
middlewares.py
# 在爬虫中间件中
def get_proxy(self):
import requests
res=requests.get('http://192.168.1.143:5010/get/').json()
if res.get('https'):
return 'https://'+res.get('proxy')
else:
return 'http://' + res.get('proxy')
def process_request(self, request, spider):
# request 就是咱们在解析中yiedl的Request的对象
# spider 就是爬虫对象
####1 加代理--->配置文件配置
pro=self.get_proxy()
request.meta['proxy'] = pro
# 下载超时时间 download_timeout
print(request.meta)
return None
### 重点：如果中间件中出了异常，会调用中间件的process_exception
-记录日志
-把当前爬取的request对象，return出去，会被引擎重新放回调度器，等待下次执行
8.2 加cookie,修改请求头，随机生成UserAgent
加cookies直接request.cookies['']=''
然后从request.cookies中可以直接取出来
修改请求头一样的道理
request.headers['referer']='http://127.0.0.1:8000'
# 随机生成UserAgent
from fake_useragent import UserAgent
ua = UserAgent()
print(ua.ie) # 随机打印ie浏览器任意版本
print(ua.firefox) # 随机打印firefox浏览器任意版本
print(ua.chrome) # 随机打印chrome浏览器任意版本
print(ua.random) # 随机打印任意厂家的浏览器
from fake_useragent import UserAgent
ua = UserAgent()
request.headers['User-Agent'] = ua.random
print(request.headers)
8.3 集成selenium
# 使用scrapy，爬取网页，本质跟使用requests模块是一样的，模拟发送http请求，有的网站，页面可能不是一次http请求返回的所有数据，会执行js，再发ajax，得到的所有数据，所有有的网页，
咱们可以使用selenium去爬取
# 字符串和bytes相互转化
字符串转bytes
-方式一：lqz'.encode(encoding='utf-8')
-方式二：bytest('字符串'，encoding='utf-8')
bytes转字符串
-方式一：b'lqz'.decode(encoding='utf-8')
-方式二：str('bytes格式'，encoding='utf-8')
# 使用步骤：只用selenium爬取cnblogs的首页和下一页 （一旦使用selenium速度就慢）
-第一步：在爬虫类的类属性中写
class CnblogsSpider(scrapy.Spider):
bro = webdriver.Chrome(executable_path='./chromedriver.exe')
-第二步：在中间件中使用selenium爬取
if request.meta.get('user_selenium'): #有的用，有的不用
spider.bro.get(request.url)
from scrapy.http import HtmlResponse
response = HtmlResponse(url=request.url, body=bytes(spider.bro.page_source, encoding='utf-8'))
return response
else:
return None
-第三步：在爬虫类中关闭
def close(self, spider, reason):
self.bro.close()
9 去重规则源码分析（布隆过滤器）
# scrapy 可以去重
# 研究去重的底层实现是如何实现的
-我们想的话：把爬取过的网址，放在集合中，下次爬取之前，先看集合中有没有，如果有，就不爬了
-源码在哪去的重？调度器---》调度器源码
# 源码 调度器的类：from scrapy.core.scheduler import Scheduler
# 这个方法如果return True表示这个request要爬取，如果return表示这个网址就不爬了(已经爬过了)
def enqueue_request(self, request: Request) -> bool:
# request当次要爬取的地址对象
if not request.dont_filter and self.df.request_seen(request):
# 有的请情况，在爬虫中解析出来的网址，不想爬了，就就可以指定
# yield Request(url=url, callback=self.detail_parse, meta={'item': item},dont_filter=True)
# 如果符合这个条件，表示这个网址已经爬过了
return False
return True
-self.df 是去重类的对象 RFPDupeFilter
-在配置文件中如果配置了：DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'表示，使用它作为去重类，按照它的规则做去重
-RFPDupeFilter的request_seen
def request_seen(self, request: Request) -> bool:
# request_fingerprint 生成指纹
fp = self.request_fingerprint(request) #request当次要爬取的地址对象
#判断 fp 在不在集合中，如果在，return True
if fp in self.fingerprints:
return True
#如果不在，加入到集合，return False
self.fingerprints.add(fp)
return False
-生成指纹，指纹是什么？
-www.cnblogs.com?name=lqz&age=19
-www.cnblogs.com?age=19&name=lqz
-上面的两种地址生成的指纹是一样的
# 测试指纹
from scrapy.utils.request import RequestFingerprinter
from scrapy import Request
fingerprinter = RequestFingerprinter()
request1 = Request(url='http://www.cnblogs.com?name=lqz&age=20')
request2 = Request(url='http://www.cnblogs.com?age=19&name=lqz')
res1 = fingerprinter.fingerprint(request1).hex()
res2 = fingerprinter.fingerprint(request2).hex()
print(res1)
print(res2)
# 总结：scrapy的去重规则
-根据配置的去重类RFPDupeFilter的request_seen方法，如果返回True，就不爬了，如果返回False就爬
-后期咱们可以使用自己定义的去重类，实现去重
# 更小内存实现去重
-如果是集合：存的数据库越多，占内存空间越大，如果数据量特别大，可以使用布隆过滤器实现去重
# 布隆过滤器：https://zhuanlan.zhihu.com/p/94668361
#bloomfilter：是一个通过多哈希函数映射到一张表的数据结构，能够快速的判断一个元素在一个集合内是否存在，具有很好的空间和时间效率。（典型例子，爬虫url去重）
# 原理： BloomFilter 会开辟一个m位的bitArray(位数组)，开始所有数据全部置 0 。当一个元素（www.baidu.com）过来时，能过多个哈希函数（h1,h2,h3....）计算不同的在哈希值，
并通过哈希值找到对应的bitArray下标处，将里面的值 0 置为 1 。
# Python中使用布隆过滤器
# 测试布隆过滤器
# 可以自动扩容指定错误率，底层数组如果大于了错误率会自动扩容
# from pybloom_live import ScalableBloomFilter
# 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)
# bloom.add(url2)
# print(url in bloom)
# print(url2 in bloom)
from pybloom_live import BloomFilter
# 定长
bf = BloomFilter(capacity=10)
url = 'www.baidu.com'
bf.add(url)
bf.add('aaaa')
bf.add('ggg')
bf.add('deww')
bf.add('aerqaaa')
bf.add('ae2rqaaa')
bf.add('aerweqaaa')
bf.add('aerwewqaaa')
bf.add('aerereweqaaa')
bf.add('we')
print(url in bf)
print("wa" in bf)
# 重写scrapy的过滤类
10 scrapy-redis实现分布式爬虫
# 什么是分布式爬虫
-原来使用一台机器爬取cnblogs整站
-现在想使用3台机器爬取cnblogs整站
# 如果变成分布式，面临的问题
-1 去重集合，我们要使用同一个----》redis集合
-2 多台机器使用同一个调度器：Scheduler，排队爬取，使用同一个队列
# scrapy-redis 已经解决这个问题了，我只需要在我们单机基础上，改动一点，就变成了分布式爬虫
# 使用步骤
第一步：安装scrapy-redis ---》pip3 install scrapy-redis
第二步：改造爬虫类
from scrapy_redis.spiders import RedisSpider
class CnblogSpider(RedisSpider):
name = 'cnblog_redis'
allowed_domains = ['cnblogs.com']
# 写一个key：redis列表的key，起始爬取的地址
redis_key = 'myspider:start_urls'
第三步：配置文件配置
# 分布式爬虫配置
# 去重规则使用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, #简单看
}
第四步：在多台机器上启动scrapy项目，在一台机器起了多个scrapy爬虫进程，就相当于多台机器
-进程，线程，协程。。。
-进程间数据隔离 IPC
第五步：把起始爬取的地址放到redis的列表中
lpush mycrawler:start_urls http://www.cnblogs.com/
浙公网安备 33010602011771号