加代理，cookie，header，加入selenium

加代理

1.在爬虫中间件中(middlewares.py)
class CnblogsDownloaderMiddleware:

    def get_proxy(self):
        import requests
        res = requests.get('http://192.168.1.100:5000/get/').json()
        return 'https://' + res.get('proxy') if res.get('https') else 'http://' + res.get('proxy')
        # return res.get('https') + res.get('proxy')

    @classmethod
    def from_crawler(cls, crawler):
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # 默认没有代理，取报错
        request.meta['proxy'] = self.get_proxy()
        print(request.meta)
        return None
'如果中间件中出了异常，会调用中间件的process_exception'

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

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

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

3.随机生成UserAgent
-要下载模块fake-useragent
from fake_useragent import UserAgent

ua = UserAgent()
print(ua.ie)  # 随机打印ie浏览器任意版本
print(ua.firefox)  # 随机打印firefox浏览器任意版本
print(ua.chrome)  # 随机打印chrome浏览器任意版本
print(ua.random)  # 随机打印任意厂家的浏览器
-随机生成UserAgent
from fake_useragent import UserAgent
ua = UserAgent()
request.headers['User-Agent'] = ua.random
print(request.headers)

集成selenium

1.使用scrapy，爬取网页，本质跟使用requests模块是一样的，模拟发送http请求，有的网站，页面可能不是一次http请求返回的所有数据，会执行js，再发ajax，得到的所有数据、网页，所以可以使用selenium去爬取

2.使用
-在爬虫类的类属性中写
from selenium import webdriver
class CnblogsSpider(scrapy.Spider):
    bro = webdriver.Chrome(executable_path='./chromedriver.exe')
    def parse(self, response):
        yield Request(url=next_url, callback=self.parse, meta={'user_selenium': True})

-在中间件中使用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
return None

-在爬虫类中关闭
def close(self, spider, reason):
    self.bro.close()

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

1.scrapy可以去重
1.1在爬取网站时，把爬取过的网址，放在集合中，下次爬取之前，先看集合中有没有，如果有，就不爬了
-源码在调度器源码去的重
from scrapy.core.scheduler import Scheduler, BaseScheduler
-这个方法如果return True表示这个request要爬取，如果return表示这个网址就不爬了(已经爬过了)
def enqueue_request(self, request: Request) -> bool:
    # request当次要爬取的地址对象
    if not request.dont_filter and self.df.request_seen(request):
        # 如果符合这个条件，表示这个网址已经爬过了 
        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)
    if self.file:
        self.file.write(fp + '\n')
    return False

1.2什么是生成指纹
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=19')
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)
# e3326dffda6a648041faa4a234d28b626b7864de
# e3326dffda6a648041faa4a234d28b626b7864de

1.3scrapy的去重规则
-根据配置的去重类RFPDupeFilter的request_seen方法，如果返回True，就不爬了，如果返回False就爬
-可以使用自己定义的去重类，实现去重
dont_filter=True

1.4更小内存实现去重
如果是集合，存的数据库越多，占内存空间越大。如果数据量特别大，可以使用布隆过滤器实现去重

2.布隆过滤器：https://zhuanlan.zhihu.com/p/94668361
-bloomfilter：是一个通过多哈希函数映射到一张表的数据结构，能够快速的判断一个元素在一个集合内是否存在，具有很好的空间和时间效率(典型例子，爬虫url去重)
-BloomFilter 会开辟一个m位的bitArray(位数组)，开始所有数据全部置 0 。当一个元素（www.baidu.com）过来时，能过多个哈希函数（h1,h2,h3....）计算不同的在哈希值，并通过哈希值找到对应的bitArray下标处，将里面的值 0 置为 1

2.1python中使用的布隆过滤器
-可以自动扩容指定错误率，底层数组如果大于了错误率会自动扩容
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-redis实现分布式爬虫

1.什么是分布式爬虫
-原来使用一台机器爬取cnblogs整站
-现在想使用3台机器爬取cnblogs整站

2.如果变成分布式，面临的问题
-去重集合，我们要使用同一个----》redis集合
-多台机器使用同一个调度器：Scheduler，排队爬取，使用同一个队列

3.scrapy-redis 已经解决这个问题了，我只需要在我们单机基础上，改动一点，就变成了分布式爬虫
3.1安装scrapy-redis  ---》pip3 install scrapy-redis
3.2改造爬虫类
from scrapy_redis.spiders import RedisSpider


class CnblogsSpider(RedisSpider):
    name = 'cnblogs'
    allowed_domains = ['www.cnblogs.com']
    # 写一个key：redis列表的key，起始爬取的地址
    redis_key = 'myspider:start_urls'
3.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,  # 简单看
}
3.4在多台机器上启动scrapy项目，在一台机器起了多个scrapy爬虫进程，就相当于多台机器
3.5把起始爬取的地址放到redis的列表中
lpush mycrawler:start_urls http://www.cnblogs.com/

Flask

Flask快速使用

-pip3 install flask  # 最新2.2.2


from flask import Flask

app = Flask(__name__)

# 注册路由
@app.route('/index')
def index():
    return '你看到我了'


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