异步爬虫框架与协程浅析

最新推荐文章于 2023-11-26 08:00:00 发布
最新推荐文章于 2023-11-26 08:00:00 发布
阅读量773 收藏 5
点赞数 1
分类专栏： web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33339479/article/details/78597949
版权

异步爬虫框架与协程浅析

经典原文使用协成完成异步爬虫原文链接

根据分享原文链接。

Python基于协程的实现，其实是利用了Python生成器的特性完成的，Python生成器的原理其实涉及到用户态绿色线程的实现，用户态绿色线程是指通过在用户态实现函数之间执行的跳转，正常的函数调用在底层执行时会创建堆栈，将函数执行的数据进行压栈，保存函数运行时的数据，在函数执行完成后，函数运行后的数据会被丢弃，不会保存，实现函数之间的来回切换主要就是为了当在函数A中执行时，在A没有执行完成时，切换到B函数执行，此时需要将A运行的数据进行压栈，保存A在运行时产生的数据，然后切换到B当B在执行一段时间后，再切换回A的时候，此时保存B函数运行的现场，恢复A上次运行的现场，此时继续执行A函数，这样就达到了在用户态实现了函数之间的跳转。

Python中yield的基本用法

代码基于Python3.5.2

#coding:utf-8


def a():
    val_a = "val_a"
    print("start a")
    data = yield val_a
    print("end a")
    return data


def b():
    val_b = "val_b"
    print("start b")
    res = yield from a()
    print("end b")
    print("res : ", res)


def start():
    _b = b()
    print("recv :", _b.send(None))  # 装饰器开始
    try:
        _b.send("data") # 函数a中接受的数据赋值给data,随即函数a执行完毕
    except StopIteration:
        pass

if __name__ == '__main__':
    start()

执行时首先执行到_b.send(None)，此时函数执行到a函数中

data = yield val_a

将val_a作为结果返回给了_b.send(None),结果返回完成后执行结果完成。
接着执行a函数打印print并返回结果，此时a函数执行完成返回data,函数返回后在函数b处

_b.send("data")

此时会继续执行a函数data = yield val_a该处代码，将”data”赋值给data变量

res = yield from a()

将函数a执行完成后的结果赋值给res，此时b函数继续执行打印函数，至此调用完成。
运行结果如下：

start b
start a
recv : val_a
end a
end b
res :  data

在Python中，对于yield和yield from更详细的用法，请查阅相关资料

代码分析:

想要实现一个异步爬虫框架，
1.基于异步io必须依靠操作系统提供的io复用的支持，需要实现循环事件；
2.要想实现多个任务之间的执行，则需要将一个链接进行封装成一个事务；
3.在第2步中的事务需要在相应事件发生的时候执行相应的任务，则需要封装一个任务确保能够继续执行。
由以上三点，得出前三个类的实现。
事件循环函数，如果发生了注册的事件则调用相应的注册方法

def loop():
    while not stopped:
        events = selector.select()
        for event_key, event_mask in events:
            callback = event_key.data
            callback()

事务的封装类，主要是在注册方法时调用，此时就调用相应的方法

class Future:
    def __init__(self):
        self.result = None
        self._callback = []

    def add_done_callback(self, fn):
        self._callback.append(fn)

    def set_result(self, result):
        self.result = result
        for fn in self._callback:
            fn(self)

    def __iter__(self):
        yield self
        return self.result

任务类，将要处理的流程封装好，等待事件注册发生时，继续执行coro的流程

class Task:
    def __init__(self, coro):
        self.coro = coro
        f = Future()
        f.set_result(None)
        self.step(f)

    def step(self, future):
        try:
            next_future = self.coro.send(future.result)
            print("next_future: ", next_future)
        except StopIteration as e:
            print("step stop :", e.value)
            return

        next_future.add_done_callback(self.step)

得出这三个概念后，全部代码如下

#coding:utf-8
import socket
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE
selector = DefaultSelector()


class Future:
    def __init__(self):
        self.result = None
        self._callback = []

    def add_done_callback(self, fn):
        self._callback.append(fn)       # 将fn添加到回调执行函数中

    def set_result(self, result):   
        self.result = result            # 重置Future.result的值
        for fn in self._callback:       
            fn(self)                    # 执行回调函数，此时会执行Task.step方法

    def __iter__(self):
        yield self                      # 迭代返回
        return self.result


def connect(sock, address):
    f = Future()                        # 实例一个事物
    sock.setblocking(False)             # 设置连接为非阻塞
    try:
        sock.connect(address)           # 连接远程
    except BlockingIOError:
        pass

    def on_connected():
        f.set_result(None)              # 连接完成后需要将流程往下继续执行
    selector.register(sock.fileno(), EVENT_WRITE, on_connected)     # 注册写事件，如果连接建立后的回调函数
    print("connect")
    yield from f                        # 返回事物
    selector.unregister(sock.fileno())  # 当函数执行完成后取消注册的事件


class Task:
    def __init__(self, coro):
        self.coro = coro                # coro就是由yield from封装的主流程
        f = Future()                    # 实例化一个事物
        f.set_result(None)              # 设置执行的值
        self.step(f)                    # 调用step方法

    def step(self, future):
        try:
            next_future = self.coro.send(future.result)   # 继续执行主流程中的流程
            print("next_future: ", next_future)
        except StopIteration as e:
            print("step stop :", e.value)
            return

        next_future.add_done_callback(self.step)    # 将返回的对象添加回调函数，该例中，next_funture大多返回f实例


def read(sock):
    f = Future()                        # 实例化一个事物

    def on_readable():
        f.set_result(sock.recv(1))      # 将连接接受的数据设置到事物中，作为返回值

    selector.register(sock.fileno(), EVENT_READ, on_readable)  # 注册连接的读事件和回调函数
    chunk = yield f                     # 将接受的数据返回
    selector.unregister(sock.fileno())  # 取消连接的事件
    return chunk                        # 将数据返回


def read_all(sock):
    response = []
    chunk = yield from read(sock)       # 接受单次返回的数据
    while chunk:                        # 如果返回的数据有，则继续
        response.append(chunk)          # 加入到返回数据列表
        chunk = yield from read(sock)   # 继续获取连接数据
    return b''.join(response)           # 返回所有接受的数据


stopped = False                         # 循环执行的标志


class Fetcher:
    def __init__(self, url):            # 主流程
        self.response = b''             # 响应结果
        self.url = url                  # 访问链接
        self.sock = None                # 链接实例

    def fetch(self):
        sock = socket.socket()          # 链接实例
        yield from connect(sock, ('xkcd.com', 80))          # 连接远端
        request = 'GET {} HTTP/1.0\r\nHost: xkcd.com\r\n\n'.format(self.url) # 序列化请求
        sock.send(request.encode("ascii"))                  # 发送数据出去
        self.response = yield from read_all(sock)           # 读取所有的数据
        print("response: ", self.response)      


def loop():
    while not stopped:
        events = selector.select()                          # 获取注册返回
        for event_key, event_mask in events:                # 
            callback = event_key.data                       # 获取注册事件的注册回调函数
            callback()                                      # 执行回调函数


if __name__ == "__main__":
    fetcher = Fetcher('/353/')                              # 实例化一个主流程实例
    Task(fetcher.fetch())                                   # 用任务包装主流程
    loop()                                                  # 启动循环

流程解读:

首先，fetcher = Fetcher(‘/353/’) ，实例化一个主流程实例，然后调用fetcher.fetch()作为参数值传入Task中，此时Task实例化时，执行

    def __init__(self, coro):
        self.coro = coro                # coro就是由yield from封装的主流程
        f = Future()                    # 实例化一个事物
        f.set_result(None)              # 设置执行的值
        self.step(f)                    # 调用step方法

    def step(self, future):
        try:
            next_future = self.coro.send(future.result)   # 继续执行主流程中的流程
            print("next_future: ", next_future)
        except StopIteration as e:
            print("step stop :", e.value)
            return

        next_future.add_done_callback(self.step)    # 将返回的对象添加回调函数，该例中，next_funture大多返回f实例

此时future.result=None，执行step方法，此时会执行

next_future = self.coro.send(future.result)   # 继续执行主流程中的流程

此时会执行到

def connect(sock, address):
    f = Future()                        # 实例一个事物
    sock.setblocking(False)             # 设置连接为非阻塞
    try:
        sock.connect(address)           # 连接远程
    except BlockingIOError:
        pass

    def on_connected():
        f.set_result(None)              # 连接完成后需要将流程往下继续执行
    selector.register(sock.fileno(), EVENT_WRITE, on_connected)     # 注册写事件，如果连接建立后的回调函数
    print("connect")
    yield from f                        # 返回事物
    selector.unregister(sock.fileno())  # 当函数执行完成后取消注册的事件

连接远程端口，注册连接的读事件和回调函数，并返回f实例，此时
在step函数中继续执行

next_future.add_done_callback(self.step)

将step函数添加到f的回调函数中，
当远程连接成功后此时会调用loop中事件的回调函数，此时就执行

    def on_connected():
        f.set_result(None)              # 连接完成后需要将流程往下继续执行

此时实例f的_callback中已经有了Task.step函数，此时就执行

    def set_result(self, result):
        self.result = result            # 重置Future.result的值
        for fn in self._callback:
            fn(self)                    # 执行回调函数，此时会执行Task.stop方法

当调用fn(self)时，就执行以下代码

    def step(self, future):
        try:
            next_future = self.coro.send(future.result)   # 继续执行主流程中的流程
            print("next_future: ", next_future)
        except StopIteration as e:
            print("step stop :", e.value)
            return

        next_future.add_done_callback(self.step)    # 将返回的对象添加回调函数，该例中，next_funture大多返回f实例

此时继续执行coro主流程的代码，此时就执行

        request = 'GET {} HTTP/1.0\r\nHost: xkcd.com\r\n\n'.format(self.url) # 序列化请求
        sock.send(request.encode("ascii"))                  # 发送数据出去
        self.response = yield from read_all(sock)           # 读取所有的数据

此时会继续执行yield from read_all(sock)中的函数，

def read_all(sock):
    response = []
    chunk = yield from read(sock)       # 接受单次返回的数据
    while chunk:                        # 如果返回的数据有，则继续
        response.append(chunk)          # 加入到返回数据列表
        chunk = yield from read(sock)   # 继续获取连接数据
    return b''.join(response)           # 返回所有接受的数据

第一次进去时，会执行

yield from read(sock)

执行read函数

def read(sock):
    f = Future()                        # 实例化一个事物

    def on_readable():
        f.set_result(sock.recv(1))      # 将连接接受的数据设置到事物中，作为返回值

    selector.register(sock.fileno(), EVENT_READ, on_readable)  # 注册连接的读事件和回调函数
    chunk = yield f                     # 将接受的数据返回
    selector.unregister(sock.fileno())  # 取消连接的事件
    return chunk                        # 将数据返回

此时，先实例化一个f,注册连接的读事件和回调函数，然后返回f,此时返回的f会继续执行

next_future.add_done_callback(self.step)    # 将返回的对象添加回调函数，该例中，next_funture大多返回f实例

将self.step函数添加到实例f的回调执行函数中。
当读事件发生后，执行了相应的回调函数

    def on_readable():
        f.set_result(sock.recv(1))      # 将连接接受的数据设置到事物中，作为返回值

将sock.recv(1)的数据作为result，设置到f.result中，此时再执行

next_future = self.coro.send(future.result)   # 继续执行主流程中的流程

此时coro主流程中中断的地方

    chunk = yield f                     # 将接受的数据返回

此时，chunk就是f.result的值，此时继续往下执行

    selector.unregister(sock.fileno())  # 取消连接的事件
    return chunk                        # 将数据返回

当返回chunk时，此时

    chunk = yield from read(sock)       # 接受单次返回的数据
        while chunk:                        # 如果返回的数据有，则继续
        response.append(chunk)          # 加入到返回数据列表
        chunk = yield from read(sock)   # 继续获取连接数据

接受的就是chunk数据，然后循环执行该循环，直到所有数据读取完毕
此时执行

       self.response = yield from read_all(sock)           # 读取所有的数据

所有响应数据返回给self.response此时，数据读取完毕。
一个简易的异步爬虫框架的原理分析完毕。

小屋子大侠
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python3爬虫中异步协程的用法
12-17
1. 前言 在执行一些 IO 密集型任务的时候，程序常常会因为等待 IO 而阻塞。比如在网络爬虫中，如果我们使用 requests ...在了解异步协程之前，我们首先得了解一些基础概念，如阻塞和非阻塞、同步和异步、多进程和协程。
Python有哪些常见的、好用的爬虫框架？
m0_59235945的博客
05-25 725
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取哈）
Scrapy爬虫异步框架(一篇文章齐全)
Python
11-26 2457
1、Scrapy框架初识2、Scrapy框架持久化存储（点击前往查阅）3、Scrapy框架内置管道（点击前往查阅）4、Scrapy框架中间件（点击前往查阅）Scrapy 是一个开源的、基于Python的爬虫框架，它提供了强大而灵活的工具，用于快速、高效地提取信息。Scrapy包含了自动处理请求、处理Cookies、自动跟踪链接、下载中间件等功能。
Python爬虫框架有哪些？10个Python爬虫框架推荐
程序员小麦的博客
07-07 4484
在大数据时代，掌握数据就掌握了企业发展的方向。爬虫作为抓取互联网数据的一个途径，成为企业需求量非常大的岗位之一。一般情况下小型的爬虫需求直接使用request库+BS4就可以解决了。稍微复杂一点的可以使用selenium解决JS的异步加载问题。而如果遇到大型的爬虫需求，则需要考虑使用框架了。下面我们来一起学习以及各框架。
异步爬虫框架scrapy
sumatray的博客
02-18 493
可能找不到win32api模块 ---windows系统中常见。
异步爬虫（高效爬虫）
weixin_46287157的博客
03-12 1202
如果有多个URL等待我们爬取，我们通常是一次只能爬取一个，爬取效率低，异步爬虫可以提高爬取效率，可以一次多多个URL同时同时发起请求异步爬虫方式：一、多线程、多进程（不建议）：可以为爬取阻塞（多个URL等待爬取）单独开启线程或进程，多个爬取URL异步执行（不能开启无限多个）二、线程池、进程池：可以降低系统对进程或者线程创建和消除的频率，从而降低系统的开销，池中进程或线程的数量是有上限的。
python爬虫之异步协程代码
08-19
python爬虫之异步协程代码
超牛逼的异步协程爬虫
12-21
本来这篇文章只是用来记录一下学习异步协程爬虫的笔记，感谢CSDN的大力支持，引来了很多关注和浏览，也有很多大佬的批评指针。 事先声明：本文只是学习使用，在爬虫的实战应用中还要添加诸多限制，比如UA伪装，添加...
python爬虫-超高速异步协程Python爬虫算法实现.zip
最新发布
02-25
python爬虫_超高速异步协程Python爬虫算法实现.zip
一文搞定异步爬虫框架Scrapy环境的安装
qq_51447436的博客
08-14 9970
一文搞定异步爬虫框架Scrapy环境的安装
爬虫异步框架
08-28
这是一个基于Python3的异步爬虫框架
python 5个顶级异步框架推荐
01-19
Python在3.4引入了 asyncio 库，3.6新增了关键字 async和await，此后，异步框架迅速发展了起来，性能上能和Node.js比肩，除非是CPU密集型任务，否则没有理由不适用异步框架。 如果你是Web开发者，现在异步Web框架上有了更多选择！ 1、Tornado Tornado 根本不是什么新框架，它最初是由FriendFeed（后被Facebook收购）在2009年发布。从一开始就提供有异步编程的功能。 Tornado 不仅仅是Web框架，同时它内置了很多异步模块，可用于自己构建异步应用。这些模块包括： 协同程序和其他原语（tornado.gen，tornado.l
异步爬虫—Scrapy框架
weixin_45620570的博客
02-05 959
scrapy异步框架核心原理 同步：下一个方法依赖于上一个方法的结果。 异步：下一个方法不依赖于上一个方法的结果。 spiders就是我们写的csdn的博客爬虫文件。scheduler是调度器，将url_s里所有的url地址统一分配，然后发给downloader，让它去向服务器请求下载。还有一个就是去重的功能，去掉重复的url请求。item pipeline用于把io存储，把数据存储到本地。...
【Python自查手册】之多协程爬虫Scrapy框架的用法
jety的营销圈子
02-14 638
import scrapy #导入了scrapy。目的是，我们等会所创建的类将直接继承scrapy中的scrapy.Item类。这样，有许多好用属性和方法，就能够直接使用。比如到后面，引擎能将item类的对象发给Item Pipeline（数据管道）处理。
清华-尹成老师-Python爬虫day24
01-22
尹成老师带你步入python爬虫的殿堂，讲课生动风趣、深入浅出，全套视频内容充实，整个教程以python语言为核心，完整精彩的演练了python爬虫操作流程以及各种精彩的小项目等，非常适合大家学习！
Ruia异步爬虫框架快速开始教程
howie6879's blog
04-04 1249
Ruia爬虫框架中文教程文档
第16讲：异步爬虫的原理和解析
菜鸡小白的成长记录
01-11 1883
我们知道爬虫是 IO 密集型任务，比如如果我们使用 requests 库来爬取某个站点的话，发出一个请求之后，程序必须要等待网站返回响应之后才能接着运行，而在等待响应的过程中，整个爬虫程序是一直在等待的，实际上没有做任何的事情。对于这种情况我们有没有优化方案呢？ 实例引入 比如在这里我们看这么一个示例网站：https://static4.scrape.cuiqingcai.com/，如图所示。 这个网站在内部实现返回响应的逻辑的时候特意加了 5 秒的延迟，也就是说如果我们用 requests 来爬取其中某
Python小爬虫之协程爬虫快速上手
`or 1 or 不正经の泡泡
03-04 2485
文章目录前言协程协程快速上手协程异步运行工作流程任务管理aiohttp异步保存异步回调 前言 爬虫是个好东西，最近要用用这玩意，所以顺便把以前的小东西给发出来，水几篇博客~ 协程 首先明确一点，线程不是多线程，线程本质上还是单线程，但是这个线程的特点是当当前线程进入到IO状态的时候，CPU会自动切换任务从而提高系统的整体运行效率。没错这个协程其实就和操作系统的多道处理机制是一样的。实现的效果有点类似使用多线程，或者线程池，但是协程是更加轻量级的，本质上就是一个单线程在来回切换。 协程快速上手 那么接下来我们
Scrapy- 异步爬虫框架-分布式爬虫scrapy-redis-python爬虫知识点8
weixin_43761516的博客
06-04 1087
一、scrapy简介 优点 可配置、可扩展性非常高 比较灵活，让稳定和快速 基于异步，内部封装了这个twisted异步网络框架，复杂，采用了大量闭包 也提供了可控的速度 队列1，保存每一页的url，爬取数据 爬取的数据 后 保存到队列2中，存放图片的url和名字 线程，去队列中get 图片url 并保存文件 搭好架子 cto 技术总监 架构师 ceo 二、scrapy 的工作流程 引擎–发动机–统筹全局 - 整个框架的核心 调度器–接收从引擎发过来的url，入列，一直工作到没有url了 爬虫程序：整
python 异步协程爬虫
08-30
异步协程爬虫是利用Python中的异步编程和协程机制来实现高效的网络爬虫。通过使用异步协程，可以在一个线程中同时处理多个网络请求，提高爬取数据的效率。 在Python中，可以使用asyncio库来实现异步协程爬虫。下面...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值