初识Python协程的实现

从入门到实战:openEuler 系统管理与运维笔记(持续更新) 本文为openEuler系统管理与运维的实战笔记,从CentOS迁移者视角切入,详细介绍了openEuler的生态兼容性、内核优化及安全特性。内容涵盖系统安装规划、虚拟机部署、基础命令操作、文件系统管理以及用户权限配置等核心运维技能,旨在帮助读者快速上手并掌握这一企业级操作系统的日常管理。 阅读详情

前记

简单的介绍了Python的通过Async语法实现协程的优劣性以及它的特点, 在io比较多的场景中, Async语法编写的程序会以更少的时间, 更少的资源来完成相同的任务, 这篇文章则是介绍了Python的Async语法的协程是如何实现的。

1.传统的Sync语法请求例子

还是一样, 在了解Async语法的实现之前, 先从一个Sync的语法例子开始, 现在假设有一个HTTP请求, 这个程序会通过这个请求获取对应的响应内容, 并打印出来, 代码如下:

import socket

def request(host: str) -> None:
    """模拟请求并打印响应体"""
    url: str = f"http://{host}"
    sock: socket.SocketType = socket.socket()
    sock.connect((host, 80))
    sock.send(f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii"))

    response_bytes: bytes = b""
    chunk: bytes = sock.recv(4096)
    while chunk:
        response_bytes += chunk
        chunk = sock.recv(4096)
    print("\n".join([i for i in response_bytes.decode().split("\r\n")]))

if __name__ == "__main__":
    request("so1n.me")

运行程序, 程序能够正常输出, 上部分打印了对应的HTTP响应Header, 下部分打印了HTTP响应体, , 可以看到服务端叫我们以https的形式重新请求, 输出结果如下:

HTTP/1.1 301 Moved Permanently
Server: GitHub.com
Content-Type: text/html
Location: https://so1n.me/
X-GitHub-Request-Id: A744:3871:4136AF:48BD9F:6188DB50
Content-Length: 162
Accept-Ranges: bytes
Date: Mon, 08 Nov 2021 08:11:37 GMT
Via: 1.1 varnish
Age: 104
Connection: close
X-Served-By: cache-qpg1272-QPG
X-Cache: HIT
X-Cache-Hits: 2
X-Timer: S1636359097.026094,VS0,VE0
Vary: Accept-Encoding
X-Fastly-Request-ID: 22fa337f777553d33503cee5282598c6a293fb5e

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>nginx</center>
</body>
</html>

不过这里并不是想说HTTP请求是如何实现的, 具体我也不太了解, 在这个代码中, socket的默认调用是阻塞的, 当线程调用connect或者recv时(send是不用等待的, 但在高并发下需要先等待drain后才可以send, 小demo不需要用到drain方法), 程序将会暂停直到操作完成。 当一次要下载很多网页的话, 这将会如上篇文章所说的一样, 大部分的等待时间都花在io上面, cpu却一直空闲时, 而使用线程池虽然可以解决这个问题, 但是开销是很大的, 同时操作系统往往会限制一个进程,用户或者机器可以使用的线程数, 而协程却没有这些限制, 占用的资源少, 也没有系统限制瓶颈。

2.异步的请求

异步可以让一个单独的线程处理并发的操作, 不过在上面已经说过了, socket是默认阻塞的, 所以需要把socket设置为非阻塞的, socket提供了setblocking这个方法供开发者选择是否阻塞, 在设置了非阻塞后, connect和recv方法也要进行更改。

由于没有了阻塞, 程序在调用了connect后会马上返回, 只不过Python的底层是C, 这段代码在C中调用非阻塞的socket.connect后会抛出一个异常, 我们需要捕获它, 就像这样:

import socket

sock: socket.SocketType = socket.socket()
sock.setblocking(Flase)
try:
    sock.connect(("so1n.me", 80))
except BlockingIOError:
    pass

经过一顿操作后, 就开始申请建立连接了, 但是我们还不知道连接啥时候完成建立, 由于连接没建立时调用send会报错, 所以可以一直轮询调用send直到没报错就认为是成功(真实代码需要加超时):

while True:
    try: 
        sock.send(request)
        break
    except OSError as e:
        pass

但是这样让CPU空转太浪费性能了, 而且期间还不能做别的事情, 就像我们点外卖后一直打电话过去问饭菜做好了没有, 十分浪费电话费用, 要是饭菜做完了就打电话告诉我们, 那就只产生了一笔费用, 非常的省钱(正常情况下也是这样子)。 这时就需要事件循环登场了,在类UNIX中, 有一个叫select的功能, 它可以等待事件发生后再调用监听的函数, 不过一开始的实现性能不是很好, 在Linux上被epoll取代, 不过接口是类似的, 所在在Python中把这几个不同的事件循环都封装在selectors库中, 同时可以通过DefaultSelector从系统中挑出最好的类select函数。 这里先暂时不说事件循环的原理, 事件循环最主要的是他名字的两部分, 一个是事件, 一个是循环, 在Python中, 可以通过如下方法把事件注册到事件循环中:

def demo(): pass

selector.register(fd, EVENT_WRITE, demo)

这样这个事件循环就会监听对应的文件描述符fd, 当这个文件描述符触发写入事件(EVENT_WRITE)时,事件循环就会告诉我们可以去调用注册的函数demo。不过如果把上面的代码都改为这种方法去运行的话就会发现, 程序好像没跑就结束了, 但程序其实是有跑的, 只不过他们是完成的了注册, 然后就等待开发者接收事件循环的事件进行下一步的操作, 所以我们只需要在代码的最后面写上如下代码:

while True:
    for key, mask in selector.select():
        key.data()

这样程序就会一直运行, 当捕获到事件的时候, 就会通过for循环告诉我们, 其中key.data是我们注册的回调函数, 当事件发生时, 就会通知我们, 我们可以通过拿到回调函数然后就运行, 了解完毕后, 我们可以来编写我们的第一个并发程序, 他实现了一个简单的I/O复用的小逻辑, 代码和注释如下:

import socket
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE

# 选择事件循环
selector: DefaultSelector = DefaultSelector()
# 用于判断是否有事件在运行
running_cnt: int = 0

def request(host: str) -> None:
    """模拟请求并打印响应体"""
    # 告诉主函数, 自己的事件还在运行
    global running_cnt
    running_cnt += 1
    
    # 初始化socket
    url: str = f"http://{host}"
    sock: socket.SocketType = socket.socket()
    sock.setblocking(False)
    try:
        sock.connect((host, 80))
    except BlockingIOError:
        pass

    response_bytes: bytes = b""

    def read_response() -> None:
        """接收响应参数, 并判断请求是否结束"""
        nonlocal response_bytes
        chunk: bytes = sock.recv(4096)
        print(f"recv {host} body success")
        if chunk:
            response_bytes += chunk
        else:
            # 没有数据代表请求结束了, 注销监听
            selector.unregister(sock.fileno())
            global running_cnt
            running_cnt -= 1

    def connected() -> None:
        """socket建立连接时的回调"""
        # 取消监听
        selector.unregister(sock.fileno())
        print(f"{host} connect success")
        # 发送请求, 并监听读事件, 以及注册对应的接收响应函数
        sock.send(f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii"))
        selector.register(sock.fileno(), EVENT_READ, read_response)

    selector.register(sock.fileno(), EVENT_WRITE, connected)

if __name__ == "__main__":
    # 同时多个请求
    request("so1n.me")
    request("github.com")
    request("google.com")
    request("baidu.com")
    # 监听是否有事件在运行
    while running_cnt > 0:
        # 等待事件循环通知事件是否已经完成
        for key, mask in selector.select():
            key.data()

这段代码接近同时注册了4个请求并注册建立连接回调, 然后就进入事件循环逻辑, 也就是把控制权交给事件循环, 直到事件循环告诉程序说收到了socket建立的通知, 程序就会取消注册的回调然后发送请求, 并注册一个读的事件回调, 然后又把控制权交给事件循环, 直到收到了响应的结果才进入处理响应结果函数并且只有收完所有响应结果才会退出程序。 下面是我其中的一次执行结果

so1n.me connect success
github.com connect success
google.com connect success
recv google.com body success
recv google.com body success
baidu.com connect success
recv github.com body success
recv github.com body success
recv baidu.com body success
recv baidu.com body success
recv so1n.me body success
recv so1n.me body success

可以看到他们的执行顺序是随机的, 不是严格的按照so1n.me, github.com, google.com, baidu.com顺序执行, 同时他们执行速度很快, 这个程序的耗时约等于响应时长最长的函数耗时。 但是可以看出, 这个程序里面出现了两个回调, 回调会让代码变得非常的奇怪, 降低可读性, 也容易造成回调地狱, 而且当回调发生报错的时候, 我们是很难知道这是由于什么导致的错误, 因为它的上下文丢失了, 这样子排查问题十分的困惑。 作为程序员, 一般都不止满足于速度快的代码, 真正想要的是又快, 又能像Sync的代码一样简单, 可读性强, 也能容易排查问题的代码, 这种组合形式的代码的设计模式就叫协程。

协程出现得很早, 它不像线程一样, 被系统调度, 而是能自主的暂停, 并等待事件循环通知恢复。由于协程是软件层面实现的, 所以它的实现方式有很多种, 这里要说的是基于生成器的协程, 因为生成器跟协程一样, 都有暂停让步和恢复的方法(还可以通过throw来抛错), 同时它跟Async语法的协程很像, 通过了解基于生成器的协程, 可以了解Async的协程是如何实现的。

3.基于生成器的协程

3.1生成器

在了解基于生成器的协程之前, 需要先了解下生成器, Python的生成器函数与普通的函数会有一些不同, 只有普通函数中带有关键字yield, 那么它就是生成器函数, 具体有什么不同可以通过他们的字节码来了解:

In [1]: import dis

# 普通函数
In [2]: def aaa(): pass

In [3]: dis.dis(aaa)
                                                                                                                                                                                
  1           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE

# 普通函数调用函数
In [4]: def bbb(): 
   ...:     aaa() 
   ...:


In [5]: dis.dis(bbb)

  2           0 LOAD_GLOBAL              0 (aaa)
              2 CALL_FUNCTION            0
              4 POP_TOP
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

# 普通生成器函数
In [6]: def ccc(): yield

In [7]: dis.dis(ccc)
                                                                                                                                                                                
  1           0 LOAD_CONST               0 (None)
              2 YIELD_VALUE
              4 POP_TOP
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

上面分别是普通函数, 普通函数调用函数和普通生成器函数的字节码, 从字节码可以看出来, 最简单的函数只需要LOAD_CONST来加载变量None压入自己的栈, 然后通过RETURN_VALUE来返回值, 而有函数调用的普通函数则先加载变量, 把全局变量的函数aaa加载到自己的栈里面, 然后通过CALL_FUNCTION来调用函数, 最后通过POP_TOP把函数的返回值从栈里抛出来, 再把通过LOAD_CONST把None压入自己的栈, 最后返回值。 而生成器函数则不一样, 它会先通过LOAD_CONST来加载变量None压入自己的栈, 然后通过YIELD_VALUE返回值, 接着通过POP_TOP弹出刚才的栈并重新把变量None压入自己的栈, 最后通过RETURN_VALUE来返回值。从字节码来分析可以很清楚的看到, 生成器能够在yield区分两个栈帧, 一个函数调用可以分为多次返回, 很符合协程多次等待的特点。

接着来看看生成器的一个使用, 这个生成器会有两次yield调用, 并在最后返回字符串'None', 代码如下:

In [8]: def demo(): 
   ...:     a = 1 
   ...:     b = 2 
   ...:     print('aaa', locals()) 
   ...:     yield 1 
   ...:     print('bbb', locals()) 
   ...:     yield 2 
   ...:     return 'None' 
   ...:
                                                                                                                                                                                                   
In [9]: demo_gen = demo()

In [10]: demo_gen.send(None)

aaa {'a': 1, 'b': 2}
Out[10]: 1

In [11]: demo_gen.send(None)

bbb {'a': 1, 'b': 2}
Out[11]: 2

In [12]: demo_gen.send(None)

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-12-8f8cb075d6af> in <module>
----> 1 demo_gen.send(None)

StopIteration: None


这段代码首先通过函数调用生成一个demo_gen的生成器对象, 然后第一次send调用时返回值1, 第二次send调用时返回值2, 第三次send调用则抛出StopIteration异常, 异常提示为None, 同时可以看到第一次打印aaa和第二次打印bbb时, 他们都能打印到当前的函数局部变量, 可以发现在即使在不同的栈帧中, 他们读取到当前的局部函数内的局部变量是一致的, 这意味着如果使用生成器来模拟协程时, 它还是会一直读取到当前上下文的, 非常的完美。

此外, Python还支持通过yield from语法来返回一个生成器, 代码如下:

In [1]: def demo_gen_1(): 
   ...:     for i in range(3): 
   ...:         yield i 
   ...:

In [2]: def demo_gen_2(): 
   ...:     yield from demo_gen_1() 
   ...:

In [3]: demo_gen_obj = demo_gen_2()

In [4]: demo_gen_obj.send(None)
                                                                                                                                                                     
Out[4]: 0

In [5]: demo_gen_obj.send(None)

Out[5]: 1

In [6]: demo_gen_obj.send(None)

Out[6]: 2

In [7]: demo_gen_obj.send(None)
                                                                                                                                    
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-7-f9922a2f64c9> in <module>
----> 1 demo_gen_obj.send(None)

StopIteration: 



通过yield from就可以很方便的支持生成器调用, 假如把每个生成器函数都当做一个协程, 那通过yield from就可以很方便的实现协程间的调用, 此外生成器的抛出异常后的提醒非常人性化, 也支持throw来抛出异常, 这样我们就可以实现在协程运行时设置异常, 比如Cancel,演示代码如下:

In [1]: def demo_exc(): 
   ...:     yield 1 
   ...:     raise RuntimeError() 
   ...:

In [2]: def demo_exc_1(): 
   ...:     for i in range(3): 
   ...:         yield i 
   ...:

In [3]: demo_exc_gen = demo_exc()

In [4]: demo_exc_gen.send(None)
                                                                                                                                                                     
Out[4]: 1

In [5]: demo_exc_gen.send(None)
                                                                                                                                     
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-5-09fbb75fdf7d> in <module>
----> 1 demo_exc_gen.send(None)

<ipython-input-1-69afbc1f9c19> in demo_exc()
      1 def demo_exc():
      2     yield 1
----> 3     raise RuntimeError()
      4 

RuntimeError: 

In [6]: demo_exc_gen_1 = demo_exc_1()

In [7]: demo_exc_gen_1.send(None)
                                                                                                                                        Out[7]: 0

In [8]: demo_exc_gen_1.send(None)
                                                                                                                                        Out[8]: 1

In [9]: demo_exc_gen_1.throw(RuntimeError)
                                                                                                                                        ---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-9-1a1cc55d71f4> in <module>
----> 1 demo_exc_gen_1.throw(RuntimeError)

<ipython-input-2-2617b2366dce> in demo_exc_1()
      1 def demo_exc_1():
      2     for i in range(3):
----> 3         yield i
      4 

RuntimeError: 

从中可以看到在运行中抛出异常时, 会有一个非常清楚的抛错, 可以明显看出错误堆栈, 同时throw指定异常后, 会在下一处yield抛出异常(所以协程调用Cancel后不会马上取消, 而是下一次调用的时候才被取消)。

3.2用生成器实现协程

我们已经简单的了解到了生成器是非常的贴合协程的编程模型, 同时也知道哪些生成器API是我们需要的API, 接下来可以模仿Asyncio的接口来实现一个简单的协程。

首先是在Asyncio中有一个封装叫Feature, 它用来表示协程正在等待将来时的结果, 以下是我根据asyncio.Feature封装的一个简单的Feature, 它的API没有asyncio.Feature全, 代码和注释如下:

class Status:
    """用于判断Future状态"""
    pending: int = 1
    finished: int = 2
    cancelled: int = 3

class Future(object):

    def __init__(self) -> None:
        """初始化时, Feature处理pending状态, 等待set result"""
        self.status: int = Status.pending
        self._result: Any = None
        self._exception: Optional[Exception] = None
        self._callbacks: List[Callable[['Future'], None]] = []

    def add_done_callback(self, fn: [['Future'], None]Callable) -> None:
        """添加完成时的回调"""
        self._callbacks.append(fn)

    def cancel(self):
        """取消当前的Feature"""
        if self.status != Status.pending:
            return False
        self.status = Status.cancelled
        for fn in self._callbacks:
            fn(self)
        return True

    def set_exception(self, exc: Exception) -> None:
        """设置异常"""
        if self.status != Status.pending:
            raise RuntimeError("Can not set exc")
        self._exception = exc
        self.status = Status.finished

    def set_result(self, result: Any) -> None:
        """设置结果"""
        if self.status != Status.pending:
            raise RuntimeError("Can not set result")
        self.status = Status.finished
        self._result = result
        for fn in self._callbacks:
            fn(self)

    def result(self):
        """获取结果"""
        if self.status == Status.cancelled:
            raise asyncio.CancelledError
        elif self.status != Status.finished:
            raise RuntimeError("Result is not read")
        elif self._exception is not None:
            raise self._exception
        return self._result


    def __iter__(self):
        """通过生成器来模拟协程, 当收到结果通知时, 会返回结果"""
        if self.status == Status.pending:
            yield self
        return self.result()

在理解Future时, 可以把它假想为一个状态机, 在启动初始化的时候是peding状态, 在运行的时候我们可以切换它的状态, 并且通过__iter__方法来支持调用者使用yield from Future()来等待Future本身, 直到收到了事件通知时, 可以得到结果。

但是可以发现这个Future是无法自我驱动, 调用了__iter__的程序不知道何时被调用了set_result, 在Asyncio中是通过一个叫Task的类来驱动Future, 它将一个协程的执行过程安排好, 并负责在事件循环中执行该协程。它主要有两个方法:

  • 1.初始化时, 会先通过send方法激活生成器
  • 2.后续被调度后马上安排下一次等待, 除非抛出StopIteration异常

还有一个支持取消运行托管协程的方法(在原代码中, Task是继承于Future, 所以Future有的它都有), 经过简化后的代码如下:

class Task:
    def __init__(self, coro: Generator) -> None:
        # 初始化状态
        self.cancelled: bool = False
        self.coro: Generator = coro
        # 预激一个普通的future
        f: Future = Future()
        f.set_result(None)
        self.step(f)

    def cancel(self) -> None:
        """用于取消托管的coro"""
        self.coro.throw(asyncio.CancelledError)

    def step(self, f: Future) -> None:
        """用于调用coro的下一步, 从第一次激活开始, 每次都添加完成时的回调, 直到遇到取消或者StopIteration异常"""
        try:
            _future = self.coro.send(f.result())
        except asyncio.CancelledError:
            self.cancelled = True
            return
        except StopIteration:
            return

        _future.add_done_callback(self.step)

这样Future和Task就封装好了, 可以简单的试一试效果如何:

In [2]:def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]: 
   ...:    result = yield from f 
   ...:    print(flag_int, result) 
   ...:
   ...:future: Future = Future() 
   ...:for i in range(3): 
   ...:    coro = wait_future(future, i) 
   ...:    # 托管wait_future这个协程, 里面的Future也会通过yield from被托管 
   ...:    Task(coro) 
   ...:
   ...:print('ready') 
   ...:future.set_result('ok') 
   ...:
   ...:future = Future() 
   ...:Task(wait_future(future, 3)).cancel() 
   ...: 
                                                                                                                                        ready
0 ok
1 ok
2 ok
---------------------------------------------------------------------------
CancelledError                            Traceback (most recent call last)
<ipython-input-2-2d1b04db2604> in <module>
     12 
     13 future = Future()
---> 14 Task(wait_future(future, 3)).cancel()

<ipython-input-1-ec3831082a88> in cancel(self)
     81 
     82     def cancel(self) -> None:
---> 83         self.coro.throw(asyncio.CancelledError)
     84 
     85     def step(self, f: Future) -> None:

<ipython-input-2-2d1b04db2604> in wait_future(f, flag_int)
      1 def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]:
----> 2     result = yield from f
      3     print(flag_int, result)
      4 
      5 future: Future = Future()

<ipython-input-1-ec3831082a88> in __iter__(self)
     68         """通过生成器来模拟协程, 当收到结果通知时, 会返回结果"""
     69         if self.status == Status.pending:
---> 70             yield self
     71         return self.result()
     72 

CancelledError: 

这段程序会先初始化Future, 并把Future传给wait_future并生成生成器, 再交由给Task托管, 预激, 由于Future是在生成器函数wait_future中通过yield from与函数绑定的, 真正被预激的其实是Future的__iter__方法中的yield self, 此时代码逻辑会暂停在yield self并返回。 在全部预激后, 通过调用Future的set_result方法, 使Future变为结束状态, 由于set_result会执行注册的回调, 这时它就会执行托管它的Task的step方法中的send方法, 代码逻辑回到Future的__iter__方法中的yield self, 并继续往下走, 然后遇到return返回结果, 并继续走下去, 从输出可以发现程序封装完成且打印了ready后, 会依次打印对应的返回结果, 而在最后一个的测试cancel方法中可以看到,Future抛出异常了, 同时这些异常很容易看懂, 能够追随到调用的地方。

现在Future和Task正常运行了, 可以跟我们一开始执行的程序进行整合, 代码如下:

class HttpRequest(object):
    def __init__(self, host: str):
        """初始化变量和sock"""
        self._host: str = host
        global running_cnt
        running_cnt += 1
        self.url: str = f"http://{host}"
        self.sock: socket.SocketType = socket.socket()
        self.sock.setblocking(False)
        try:
            self.sock.connect((host, 80))
        except BlockingIOError:
            pass

    def read(self) -> Generator[Future, None, bytes]:
        """从socket获取响应数据, 并set到Future中, 并通过Future.__iter__方法或得到数据并通过变量chunk_future返回"""
        f: Future = Future()
        selector.register(self.sock.fileno(), EVENT_READ, lambda: f.set_result(self.sock.recv(4096)))
        chunk_future = yield from f
        selector.unregister(self.sock.fileno())
        return chunk_future  # type: ignore

    def read_response(self) -> Generator[Future, None, bytes]:
        """接收响应参数, 并判断请求是否结束"""
        response_bytes: bytes = b""
        chunk = yield from self.read()
        while chunk:
            response_bytes += chunk
            chunk = yield from self.read()
        return response_bytes

    def connected(self) -> Generator[Future, None, None]:
        """socket建立连接时的回调"""
        # 取消监听
        f: Future = Future()
        selector.register(self.sock.fileno(), EVENT_WRITE, lambda: f.set_result(None))
        yield f
        selector.unregister(self.sock.fileno())
        print(f"{self._host} connect success")

    def request(self) -> Generator[Future, None, None]:
        # 发送请求, 并监听读事件, 以及注册对应的接收响应函数
        yield from self.connected()
        self.sock.send(f"GET {self.url} HTTP/1.0\r\nHost: {self._host}\r\n\r\n".encode("ascii"))
        response = yield from self.read_response()
        print(f"request {self._host} success, length:{len(response)}")
        global running_cnt
        running_cnt -= 1

if __name__ == "__main__":
    # 同时多个请求
    Task(HttpRequest("so1n.me").request())
    Task(HttpRequest("github.com").request())
    Task(HttpRequest("google.com").request())
    Task(HttpRequest("baidu.com").request())
    # 监听是否有事件在运行
    while running_cnt > 0:
        # 等待事件循环通知事件是否已经完成
        for key, mask in selector.select():
            key.data()

这段代码通过Future和生成器方法尽量的解耦回调函数, 如果忽略了HttpRequest中的connected和read方法则可以发现整段代码跟同步的代码基本上是一样的, 只是通过yield和yield from交出控制权和通过事件循环恢复控制权。 同时通过上面的异常例子可以发现异常排查非常的方便, 这样一来就没有了回调的各种糟糕的事情, 开发者只需要按照同步的思路进行开发即可, 不过我们的事件循环是一个非常简单的事件循环例子, 同时对于socket相关都没有进行封装, 也缺失一些常用的API, 而这些都会被Python官方封装到Asyncio这个库中, 通过该库, 我们可以近乎完美的编写Async语法的代码。

---------------------------END---------------------------

题外话

当下这个大数据时代不掌握一门编程语言怎么跟的上时代呢?当下最火的编程语言Python前景一片光明!如果你也想跟上时代提升自己那么请看一下.

在这里插入图片描述

感兴趣的小伙伴,赠送全套Python学习资料,包含面试题、简历资料等具体看下方。


👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

一、Python所有方向的学习路线

Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照下面的知识点去找对应的学习资源,保证自己学得较为全面。

img
img

二、Python必备开发工具

工具都帮大家整理好了,安装就可直接上手!img

三、最新Python学习笔记

当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。

img

四、Python视频合集

观看全面零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。

img

五、实战案例

纸上得来终觉浅,要学会跟着视频一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。

img

六、面试宝典

在这里插入图片描述

在这里插入图片描述

简历模板在这里插入图片描述

👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

若有侵权,请联系删除

别再死记硬背HJB方程了!用Python数值求解一个简单最优控制问题(附完整代码) 本文通过Python数值求解Hamilton-Jacobi-Bellman(HJB)方程,帮助读者从工程实践角度理解最优控制问题。教程涵盖从建立简单车辆控制模型到离散化HJB方程、实现值迭代算法及可视化结果的完整流程,适合具备Python基础的开发者学习。 阅读详情

相关推荐

告别玄学调参:手把手教你用LSTM-AutoEncoder为传感器数据做异常检测(实战篇)

本文详细介绍了LSTM-AutoEncoder在传感器数据异常检测中的工程化实践,包括数据预处理、模型架构设计和生产环境部署策略。通过结合LSTM的时间序列处理能力和AutoEncoder的特征提取优势,该方法能够有效识别温湿度、PM2.5等传感器数据的异常模式,适用于工业物联网和室内空气质量监测等场景。

weixin_29212429的博客 477

协程初识

一 什么是进程和线程 进程是什么呢 直白地讲,进程就是应用程序的启动实例。比如我们运行一个游戏,打开一个软件,就是开启了一个进程。 进程拥有代码和打开的文件资源、数据资源、独立的内存空间。 线程又是什么呢? 线程从属于进程,是程序的实际执行者。一个进程至少包含一个主线程,也可以有更多的子线程。 线程拥有自己的栈空间。 有人给出了很好的归纳: 对操作系统来说,线程是最小的执行单元...

许进进的博客 5048

懒人精灵手游内存技术分析

教学声明:全套教程教学用到的游戏采用手游私服网游进行测试,不针对任何游戏。教学只做计算机技术研究,不做其他用途。

yizhihaoren123的博客 1660

python3 协程_python3协程

Python3.5 协程原理本文讲的是Python3.5 协程原理,作为Python核心开发者之一,让我很想了解这门语言是如何运作的。我发现总有一些阴暗的角落我对其中错综复杂的细节不是很清楚,但是为了能够有助于 Python 的一些问题和其整体设计,我觉得我应该试着去理解 Python 的核心语法和内部运作机制。...文章玄学酱2017-10-191246浏览量Python并发编程协程(Cor...

weixin_39723678的博客 787

基于deepseek+dify+达梦实现自然语言查询数据库

自然语言查询数据库信息

weixin_43974943的博客 1595

基于PCIe的NVMe协议在FPGA中实现方法

NVMe协议是工作在PCIE的最上层协议层的,故需要先搞清楚PCIE。本文基于Xilinx的UltraScale+,开发工具为Vivado2021.2。NVMe的学习仍以spec为主,其它资料辅助理解,有冲突时以spec为准,必要时可对比最新版本spec。(此文重点介绍学习方法及资料,有时间再加细节)。 主要参考的文章是《老男孩读PCIe》,同时参考《古猫先生》,重点学习TLP报文部分,数据链路层和物理层的内容可以先不看。再买一本书《PCI Express 体系结构导读-王齐》用来查阅做笔记。

leixj的博客 1万+

协程asyncio_初识asyncio协程

初识asyncio协程一、基本概念​ 要想了解学习协程相关知识要先对以下几个概念先行了解:阻塞​ 阻塞状态是指程序未得到某所需计算资源时的挂起状态,简单说就是程序在等待某个操作未执行完前无法执行其他操作。非阻塞​ 非阻塞状态是指在等待某项操作执行完前可以继续运行其他操作,也就是不会被阻塞。同步​ 不同程序单元为了完成某项任务,在执行过程中以某种通信方式保证协调一致,假如有一个售票窗口,你必须等前面...

weixin_39777242的博客 145

RAD Studio 12安装全攻略:从下载到破解InterBase的完整流程(附KeyPatch使用技巧)

本文提供RAD Studio 12的完整安装指南,包括系统要求、安装步骤及InterBase数据库的高效配置方法。详细介绍了如何使用KeyPatch工具进行许可证处理,并分享了IDE优化和开发技巧,帮助开发者快速上手这一强大的跨平台开发工具。

q6r7s8t9的博客 956

一、初识asyncio协程

初识asyncio协程 一、基本概念 ​ 要想了解学习协程相关知识要先对以下几个概念先行了解: 阻塞 ​ 阻塞状态是指程序未得到某所需计算资源时的挂起状态,简单说就是程序在等待某个操作未执行完前无法执行其他操作。 非阻塞 ​ 非阻塞状态是指在等待某项操作执行完前可以继续运行其他操作,也就是不会被阻塞。 同步 ​ 不同程序单元为了完成某项任务,在执行过程中以某种通信方式保证协调一致,假如...

angbini7012的博客 292

【Unity 反向运动学插件】Final IK 一套完整的IK解决方案

Final IK是Unity中一套完整的反向运动学解决方案,提供多种IK算法(CCD、FABRIK等)和功能模块,包括全身IK、VR驱动、武器瞄准、视线跟随等。其核心是通过数学方法计算关节旋转,使末端骨骼精确到达目标位置。系统支持多约束求解、旋转限制、动画烘焙及交互系统,采用模块化设计,兼顾性能与扩展性,适用于动作游戏、VR等需要高质量角色控制的场景,是Unity生态中最成熟的IK工具链之一。

2403_88403568的博客 1008

【系统分析师】2026年-上半年真题:综合知识-答案及详解(75题完整回忆版)

系统分析师考试备考指南(2026上半年机考) 考试安排: 2026年5月23日举行,分三科连考: 综合知识+案例分析(08:30-12:30,240分钟) 论文(14:30-16:30,120分钟) 科目详情: 综合知识:75道单选(含5道英文题),满分75分,45分及格。 案例分析:5选3主观题,满分75分,45分及格。 论文:4选1论述题,满分75分,45分及格。 重点题型解析: 软件工程:结构化分析以数据字典为核心(题1)。 概率统计:独立事件概率计算(题2,三人解题概率≈0.9)。 数据库安全:DB

数据知道的博客 1895

python 之 协程 初识 及其优缺点

协程,又称微线程,纤程。英文名Coroutine。 协程是一种用户态的轻量级线程。 线程是系统级别的,它们是由操作系统调度;协程是程序级别的,由程序员根据需要自己调度。我们把一个线程中的一个个函数叫做子程序,那么子程序在执行过程中可以中断去执行别的子程序;别的子程序也可以中断回来继续执行之前的子程序,这就是协程。也就是说同一线程下的一段代码执行着执行着就可以中断,然后跳去执行另一段代码,当再次...

super_little_newbie di boker 1874

编织数据的实时脉络——构建基于MySQL的数据编织平台,实现实时数据治理

除了上述基本设置外,我们还可以根据实际应用场景自定义一些特定的监控项目。例如,对于某些高并发读写的表,可能需要特别关注它们的锁等待时间和回滚段使用率;而对于涉及到跨库关联查询的操作,则应当着重检查网络延迟及缓存命中率等因素。-- 获取InnoDB行级锁等待情况-- 统计各表的缓存命中率这段SQL脚本不仅展示了如何查询InnoDB引擎下的锁争用状况,还介绍了计算表级别缓存命中率的方法,有助于深入理解系统的运行状态。

墨夶的博客 1790

python爬虫--协程(初识)

python爬虫–协程 基本知识 event_loop:事件循环,相当于一个无限循环,我们可以把一些函数注册到这个事件循环上,当满足某些条件的时候,函数就会被循环执行。 coroutine:携程对象,我们可以将携程对象注册到事件循环中,它会被时间循环调用。我们可以使用async关键字来定义一个方法,这个方法在调用时不会被立即执行,而是返回一个协程对象。 task:任务,它是对协程对象的进一步封装, 包含了任务的各个状态。 future:代表将来执行或还没有执行的任务,实际上和task 没有本质区别。 as

qq_43710889的博客 1081

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

python协程详解_python协程详解

原博文2019-10-25 10:07 − # python协程详解 ![python协程详解](https://pic2.zhimg.com/50/v2-9f3e2152b616e89fbad86918b3c8301a_hd.jpg) ## 一、什么是协程 协程又称为微线程,协程是一种用户态的轻量级线程 协程拥有自己的寄存器和栈。...

weixin_39621379的博客 574

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

python之asyncio协程和异步编程

本文介绍了Python中的协程(coroutine)和异步编程相关知识。首先解释了协程的概念,指出它是用户态的轻量级线程,通过async/await语法实现,适合I/O密集型任务。文章通过一个简单示例演示了协程的基本用法。接着回顾了迭代器(iterator)和可迭代对象(iterable)等前置知识,包括它们的定义、实现方式以及相关内置函数iter()和next()的使用。最后简要提及了异步迭代器的概念。这些知识为后续深入理解Python异步编程和MCP协议开发奠定了基础。

Allocator的优快云博客 792

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

php 协程 爬虫,协程(效率最快、重点)--初识协程、gevent模块、协程爬虫、协程socket(一)...

https://www.cnblogs.com/post/readauth?url=/mys6/p/10803772.html初识协程# 进程 启动多个进程 进程之间是由操作系统负责调用(时间片切换,人眼看似同时运行)# 线程 启动多个线程 真正被CPU执行的最小单位实际是线程(也可形成看似同时运行并发效果,由于python语言中CPython无法多线程使用多CPU,但其他语言多线程可使用多CPU...

weixin_33326218的博客 242

小白学协程笔记1-协程概念初识-2021-2-10

文章目录前言一、从进程、线程到协程1.进程2.线程3.协程二、对称协程和非对称协程三、常见语言对协程的支持总结 前言 本文对协程的概念做了简要介绍,适合初次接触协程的小白。 一、从进程、线程到协程 1.进程 学习操作系统知识时,进程是必然绕不开的一个概念。什么是进程呢?简单来说,进程是程序的一个运行实例,是正在运行程序的一种抽象。比如当你打开游戏时,操作系统中就会创建一个游戏进程,当退出游戏时,对应进程也会终止。 那为什么要引入进程这一个概念呢?众所周知,操作系统具有并发、共享、异步、虚拟的特性。其中.

qq_37292982的博客 698

了解python中的协程

与多任务编程之一的协程相关的知识与操作方法看这一篇文章就够啦

大学生活与学习一站式解决方案. 1537

协程(效率最快、重点)--初识协程、gevent模块、协程爬虫、协程socket(一)...

https://www.cnblogs.com/post/readauth?url=/mys6/p/10803772.html初识协程# 进程 启动多个进程 进程之间是由操作系统负责调用(时间片切换,人眼看似同时运行)# 线程 启动多个线程 真正被CPU执行的最小单位实际是线程(也可形成看似同时运行并发效果,由于python语言中CPython无法多线程使用多CPU,但其他语言多线程可使用多CPU...

weixin_30548917的博客 155

python中协程的理解_Python协程深入理解(转)

原博文2019-07-28 22:35 −原文:https://www.cnblogs.com/zhaof/p/7631851.html 从语法上来看,协程和生成器类似,都是定义体中包含yield关键字的函数。yield在协程中的用法: 在协程中yield通常出现在表达式的右边,例如:datum = yield,可以产出值,也可以不产出--...01160相关推荐2019-12-10 16:29...

weixin_39662263的博客 100

Python -- 协程

9.4 协程 9.4.1 协程初识 回顾串行,并行,并发 串行:多个任务执行时,第一个任务开始执行,遇到IO阻塞就等待,IO阻塞结束之后,继续执行下个任务 并行:多核,多个形成或者进程同时进行,4个CPU同时执行四个任务 并发:多个任务看起来同时执行,实质是CPU在多个任务之间来回切换(遇到IO阻塞,计算密集型执行时间过长) 并发的本质: 遇到IO阻塞,计算密集型执行时间过长,切换 ...

143

协程asyncio_初识异步IO框架:asyncio 上篇

通过前两节的铺垫(关于协程的使用),今天我们终于可以来介绍我们整个系列的重点 -- asyncio。asyncio是Python 3.4版本引入的标准库,直接内置了对异步IO的支持。有些同学,可能很疑惑,既然有了以生成器为基础的协程,我们直接使用yield 和 yield from 不就可以手动实现对IO的调度了吗? 为何Python吃饱了没事干,老重复造轮子。这个问题很好回答,就跟为什么会有Dj...

weixin_39679370的博客 110

『python爬虫』18. 协程(保姆级图文)

『python爬虫』18. 协程(保姆级图文)

MZH 918

Python课堂01——初识Python

与其他编程语言相比较,Python有着更为简单的语法,所以学习Python对于很多刚进入编程领域的初学者来说是一个很好的选择。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。5、速度快:Python 的底层是用 C 语言写的,很多标准库和第三方库也都是用 C 写的,运行速度非常快。7、高层语言:用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。2、易学:Python极其容易上手,因为Python有极其简单的说明文档。

ZxVSaccount的博客 607

Python初识协程已经最经典的yeild生产者消费者模型

”’ 协程:协程是一种用户化的线程,类似于微线程 协程能保留上一次的调用状态,在单线程下实现并发的效果 协程的好处: 1、无须线程上下文切换的开销 2、无须原子操作锁定及同步的开销,原子操作就是一个最小的操作,如一个线程改一个数 3、方便切换控制流,简化编程模型 4、高并发、高扩展性、低成本:一个cpu支持上万的协程都不是问题,所以很适合用于高并发处理 缺点: 1、无法利用多核资...

haeasringnar的博客 4532
上一篇: Python的Sync与Async执行速度的快慢
下一篇: Python-gRPC实践(1)--gRPC简介
Python_P叔
博客等级 码龄3年 5454粉丝 827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值