爬虫-(6)

内容概览

• 加代理，cookie，header，集成selenium
• 去重规则源码分析(布隆过滤器)
• scrapy-redis实现分布式爬虫
• Flask介绍
• Flask快速使用

加代理，cookie，header，集成selenium

加代理

"""在下载中间件中"""
class MyfirstscrapyDownloaderMiddleware:

    def get_proxy(self):
        import requests
        res = requests.get('http://192.168.1.143:5010/get/').json()  # 从代理池中获取一个ip
        if res.get('https'):  # 判断是http还是https
            return 'https://' + res.get('proxy')
        else:
            return 'http://' + res.get('proxy')

    def process_request(self, request, spider):
        # request 就是咱们在解析中yiedl的Request的对象
        # spider 就是爬虫对象
        print(request.meta)
        pro = self.get_proxy()  # 加代理,配置文件中的中间件配置好
        request.meta['proxy'] = pro
        # 下载超时时间 download_timeout
        print(request.meta)
        return None

"""
重点：如果中间件中出了异常，会调用中间件的process_exception
	-记录日志
   	-把当前爬取的request对象，return出去，会被引擎重新放回调度器，等待下次执行
"""

加cookie，修改请求头，随机生成UserAgent

def process_request(self, request, spider):
	"""加cookie"""
	print(request.cookies)
	request.cookies['name']='xxx'
	print(request.cookies)
	# cookies应该是从cookie池中取出来的cookie

	"""修改请求头"""
	request.headers['referer']='http://127.0.0.1:8000'  # 上次访问地址
    # 请求头中有user_agent,这个我们想每次都随机使用一个,而不是固定的:使用fake_useragent模块,随机生成user-agent
    from fake_useragent import UserAgent
    ua = UserAgent()
    print(ua.ie)  # 随机打印ie浏览器任意版本
    print(ua.firefox)  # 随机打印firefox浏览器任意版本
    print(ua.chrome)  # 随机打印chrome浏览器任意版本
    print(ua.random)  # 随机打印任意厂家浏览器
    request.headers['User-Agent'] = ua.random

集成selenium

"""
使用scrapy爬取网页,本质和使用requests模块是一样的,模拟发送http请求;
那么有的网站页面可能不是一次http请求就返回所有数据,需要执行js,发送ajax再得到数据;
这样的网页我们可以使用selenium去爬取
"""
# 1. 在爬虫类的类属性中添加字段
class CnblogsSpider(scrapy.Spider):
    bro = webdriver.Chrome(executable_path='chromedriver.exe')
# 2. 在中间件中使用selenium爬取
"""selenium"""
if request.meta.get('user_selenium'):  # 在meta中添加了user_selenium的才使用selenium
    spider.bro.get(request.url)  # 使用selenium获取到网页数据
    from scrapy.http import HtmlResponse
    response = HtmlResponse(url=request.url, body=spider.bro.page_sourse.encode('utf-8'))  # 包装成一个response对象
    return response
# 3. 在爬虫类中关闭
def close(self, spider, reason):
    self.bro.close()
    self.bro.quit()

去重规则源码分析(布隆过滤器)

# 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 。

scrapy-redis实现分布式爬虫

"""
什么是分布式爬虫
	-原来使用一台机器爬取
	-现在使用多台机器爬取
使用分布式会出现的问题
	-爬取过的页面可能会重复爬取-->使用同一个redis集合
	-不同机器使用不同调度器会出现的问题-->Scheduler,排队爬取,使用同一个队列
"""

# scrapy-redis已经解决这个问题了,我们只需要在单机的基础上,改动一点,就变成了分布式爬虫

# 使用步骤
# 1. 安装scrapy-redis:pip install scrapy-redis

# 2. 改造爬虫类
	from scrapy_redis.spiders import RedisSpider
    class CnblogSpider(RedisSpider):
        name = 'cnblog_redis'
        allowed_domains = ['cnblogs.com']
        # 写一个key：redis列表的key，起始爬取的地址
        redis_key = 'myspider:start_urls'

# 3. 配置文件配置
	# 分布式爬虫配置
    # 去重规则使用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,  #简单看
    }

# 4. 在多台机器上启动scrapy项目;在一台机器起了多个scrapy爬虫进程,就相当于多台机器

# 5. 把起始爬取的地址放到redis的列表中:lpush mycrawler:start_urls http://www.xxxxxxx.com/

Flask介绍

# 目前python界，比较出名的web框架
	-django：大而全，web开发用的东西，它都有
    -Flask：小而精，只能完成请求与响应，session，cache，orm，admin。。。统统没有
    	-很多第三方框架，flask完全可以变成django
    -----同步框架----- django从3.x 改成了异步框架
    
    ----以下是异步框架--------
    -Tornado：非常少了，ptyhon2.x上，公司里用的多一些
    -Sanic : python 3.6 及以上
    -FastAPI
# Flask
Flask是一个基于Python开发并且依赖jinja2模板（模板语言）和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用

Flask快速使用

# 1. 安装flask;pip install flask

# 2. 新建py文件
from flask import Flask

app=Flask(__name__)

@app.route('/index')
def index():
    return 'flask'

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=8000)

# 3. 启动