Scrapy 框架 总结

总结:

1.中间件：下载中间件（拦截请求和响应）

- process_request：

- prceess_response：

- process_exception：

- 请求：

- UA伪装：

- process_request进行操作：request.headers['User-Agent'] = 'xxx'

- 代理IP：

- process_exception进行操纵：request.meta['proxy'] = 'http://ip:port'

- 响应：

- selenium在scrapy中的编码流程：

- 在爬虫类中的构造方法中实例化一个浏览器对象

- 在爬虫类的closed(self,spider)方法中关闭浏览器对象

- 在下载中间件的prceess_response方法中编写自动化的操作

2.CrawlSpider：进行全站数据的爬取

- 创建爬虫文件：scrapy genspider -t crawl xxx www.xxx.com

- 连接提取器：可以根据指定的规则进行连接的提取

- 规则解析器：将连接提取器提取到的连接进行请求的发送且根据指定规则进行数据解析

- follow=True：

- 一对一的关系。

3.分布式爬虫

- 环境安装：pip install scrapy-redis

- 爬虫文件（CralSpider）的修改：

- 导包：form scrapy_redis.spiders import RedisCrawlSpider

- 将爬虫文件的父类修改成RedisCrawlSpider

- 删除allow_demains和start_url属性

- 添加一个新属性：redis_key = 'xxx'

- 进行数据解析（yield item）

- 配置文件：
    - 在配置文件中进行指定管道的配置
    - 在配置文件中进行指定调度器的配置
- redis的配置：
    - bind注释
    - 关闭保护模式
    - 开启redis
- 运行：
    - scrapy runspider xxx.py
- 向调度器的队列中放入一个起始的url：
    - redis-cli：lpush xxx www.xxx.com

4.增量式爬虫：去重，监测

- 对url进行去重：
- 对爬取的数据进行去重：数据指纹

scrapy 限速

• settings 配置

# 开启自动限速设定：
AUTOTHROTTLE_ENABLED = True
# 设定爬取速度
DOWNLOAD_DELAY = 3

scrapy 暂定与重启

1. 然后在项目目录下创建 记录文件：spi_file/001
   
   （spi_file与spider同级）
   
   然后输入：

   scrapy crawl zhihu -s JOBDIR=spi_file/001 回车运行就行了

2. 按ctrl+c 暂停

3. 继续运行只要再次输入：scrapy crawl zhihu -s JOBDIR=remain/001就行了

4. 需要重新爬取就换个文件 002就行了

scrapy 框架的自定义命令文件

• 新建一个文件 再项目的最外层目录

from scrapy.cmdline import execute

if __name__ == '__main__':
    execute(['scrapy', 'crawl', 'haha', '--nolog'])

scrapy_redis 实现深度优先 广度优先

'''
通俗的讲：
深度优先：一个一个节点往下找，不找兄弟节点,每一个深度一个节点,先进去的后出来
广度优先:横向取值，一个节点有关联其他的节点，一同被取出来,一个深度多个节点，先进去的先出来
'''
# 在settings里面的配置：

from   scrapy_redis.queue import PriorityQueue,FifoQueue,LifoQueue
# 先进先出：广度优先
SCHEDULER_QUEUE_CLASS='scrapy_redis.queue.FifoQueue'
# 后进先出：深度优先
SCHEDULER_QUEUE_CLASS='scrapy_redis.queue.LifoQueue'
# 优先级队列：
SCHEDULER_QUEUE_CLASS='scrapy_redis.queue.PriorityQueue'
#优先级队列里面也有深度优先和广度优先：

requets.priority=1   广度优先
requets.priority=1   深度优先

# 实现原理：
'''
from scrapy_redis import queue
prio=1
depth = response.meta['depth'] + 1
requets.priority -= depth*self.prio

每一次循环，depth加1
同一个深度可以找到很多url(兄弟节点）

如果是1的话，广度优先

广度优先：
depth 优先级
1 -1
1 -1
1 -1
2 -2

从深度为1的开始往下找，优先级也越大
重点：深度越小，优先级越小
'''
def push(self, request):
    """Push a request"""
    data = self._encode_request(request)
    score = -request.priority##取反，注意

'''

优先级队列：
放进队列里面：
反一下
1 1
1 1
1 1
2 2
'''

print('这里优先级是',score)
print(request.meta.get('depth'))
# We don't use zadd method as the order of arguments change depending on
# whether the class is Redis or StrictRedis, and the option of using
# kwargs only accepts strings, not bytes.
self.server.execute_command('ZADD', self.key, score, data)
#按照分值来看

def pop(self, timeout=0):
    """
    Pop a request
    timeout not support in this queue class
    """
    # use atomic range/remove using multi/exec
    ##开启事物
    pipe = self.server.pipeline()
    pipe.multi()
    ##取第一个值出来，拿出一个删除一个
    pipe.zrange(self.key, 0, 0).zremrangebyrank(self.key, 0, 0)
    results, count = pipe.execute()
    if results:
    return self._decode_request(results[0])

# 最终pop是按照这个优先级来取值的，优先级越小的越先被取出来，优先级从小多大取值
# 总结：就是深度越小，优先级越小，越先被取出来>>广度优先(先进先出，横向取值）

# 深度优先：
先进后出：一个一个节点的往下面执行
深度越大，优先级越小，越先被pop出来
深度优先类似，就不多说了