今日内容概要

• 加代理，cookie，header，selenium
• 去重规则源码分析
• scrapy-redis实现分布式爬虫

今日内容详细

加代理，cookie，header，selenium

加代理

# 在爬虫中间件中
def get_proxy(self):
    import requests
    res = requests.get('http://192.168.1.93: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 就是爬虫对象
        # 加代理--->配置文件配置
        pro=self.get_proxy()
        request.meta['proxy'] = pro
        # 下载超时时间 download_timeout
        print(request.meta)
        return None

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

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

### 1  加cookie
print(request.cookies)
request.cookies['name']='pyy'
request.cookies=从cookie池中取出来的cookie

###2 修改请求头
print(request.headers)
request.headers['referer']='http://127.0.0.1:8000'

### 3 请求头中有user_agent，这个我们想每次都随机一个，而不是使用写死的
    -fake_useragent模块，可以随机生成user-aget
        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)

集成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'): #有的地址使用selenium，有的地址不用，根据url判断
            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()

去重规则源码分析

# 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=1000)
url='www.baidu.com'
bf.add(url)
print(url in bf)
print("www.liuqingzheng.top" in bf)

# 重写scrapy的过滤类
    class MyRFPDupeFilter(RFPDupeFilter):
        fingerprints=布隆过滤器
-布隆过滤器：极小内存校验是否重复

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/

扩展

# 1 js逆向
# 2 抓包工具的使用
    -fiddler
    -青花瓷
# 3 appnium    自动操作手机
# 3 抓取app的包，使用fiddler做代理，就可以抓取app的包
# 4 app逆向  安卓
    -java写的---->xx.jar---->反编译--->java代码
    -so 文件加密，
        python--->dll
        java---->so：c语言写的
    -so文件的动态调试---->汇编