爬虫学习-06+flask-01

一、加代理

在爬虫中间件中

  • request 就是咱们在解析中yiedl的Request的对象
  • spider 就是爬虫对象
  • 加代理--->配置文件配置

重点：如果中间件中出了异常，会调用中间件的process_exception

  • 记录日志
  • 把当前爬取的request对象，return出去，会被引擎重新放回调度器，等待下次执行
   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):
        ####1 加代理--->配置文件配置
        pro=self.get_proxy()
        request.meta['proxy'] = pro
        # 下载超时时间 download_timeout
        print(request.meta)
        return None

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

1、加cookie

print(request.cookies)
request.cookies['name']='curry'
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

  • 方式一：'curry'.encode(encoding='utf-8')
  • 方式二：bytest('字符串'，encoding='utf-8')

bytes转字符串

  • 方式一：b'curry'.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()

四、去重规则源码分析（布隆过滤器）

  • 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=curry&age=33
# www.cnblogs.com?age=33&name=curry
-上面的两种地址生成的指纹是一样的
# 测试指纹
from scrapy.utils.request import RequestFingerprinter
from scrapy import Request

fingerprinter = RequestFingerprinter()
request1 = Request(url='http://www.cnblogs.com?name=curry&age=33')
request2 = Request(url='http://www.cnblogs.com?age=33&name=curry')

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.cnblogs.com/zzjjpp/"
# 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('aaa')
bf.add('bbb')
bf.add('ccc')
bf.add('ddd')
bf.add('eee')
bf.add('fff')
bf.add('ggg')
bf.add('hhh')
bf.add('jjj')


print(url in bf)
print("wa" in bf)


# 重写scrapy的过滤类

 五、scrapy-redis实现分布式爬虫

什么是分布式爬虫？

  • 原来使用一台机器爬取cnblogs整站
  • 现在想使用3台机器爬取cnblogs整站

如果变成分布式，面临的问题

  • 去重集合，我们要使用同一个——>redis集合
  • 多台机器使用同一个调度器：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文件的动态调试----》汇编

 七、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快速使用

# 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)
posted @ 2022-12-08 21:33  初学者-11  阅读(67)  评论(0)  编辑  收藏  举报