Python asyncio深入解析:从事件循环到协程调度

实例分析asyncio实现python异步任务 实例分析asyncio实现python异步任务 1.分析对象asyncio asyncio包是python之父Guido在python仓库之外开发的一个库,其作用是使用事件循环驱动的协程实现并发。asyncio类型的事件驱动框架的运作方式为:在单个线程中使用一个主循环驱动协程执行并发活动,使用协程进行并发编程时,协程会不断把控制权让步给主循环,激活并向前运行其他协程,从而执行各个并发活动。... 阅读详情

引言

异步编程是现代Python后端开发的核心技能之一。作为从Python转向Rust的开发者,我深刻理解asyncio的设计理念和性能优势。本文将深入解析asyncio的内部机制,从事件循环到协程调度,帮助你全面掌握Python异步编程。

一、asyncio基础架构

1.1 事件循环(Event Loop)

事件循环是asyncio的核心组件,负责调度协程、处理IO事件和管理任务:

import asyncio

async def main():
    print("Hello, asyncio!")
    
# 获取事件循环
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

# Python 3.7+ 简化写法
asyncio.run(main())

1.2 协程(Coroutine)

协程是轻量级的并发原语,可以暂停和恢复执行:

async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1)  # 模拟IO操作
    return f"Data from {url}"

async def main():
    result = await fetch_data("https://api.example.com")
    print(result)

asyncio.run(main())

1.3 任务(Task)

任务是协程的包装器,可以并发执行:

async def task1():
    await asyncio.sleep(1)
    return "Task 1 completed"

async def task2():
    await asyncio.sleep(2)
    return "Task 2 completed"

async def main():
    # 创建任务
    t1 = asyncio.create_task(task1())
    t2 = asyncio.create_task(task2())
    
    # 等待所有任务完成
    results = await asyncio.gather(t1, t2)
    print(results)  # ['Task 1 completed', 'Task 2 completed']

asyncio.run(main())

二、事件循环深入

2.1 事件循环的工作原理

事件循环使用Reactor模式处理IO事件:

import asyncio
import socket

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    
    print(f"Received {message!r} from {addr!r}")
    
    writer.close()
    await writer.wait_closed()

async def main():
    server = await asyncio.start_server(
        handle_client, '127.0.0.1', 8888
    )
    
    async with server:
        await server.serve_forever()

asyncio.run(main())

2.2 事件循环实现对比

实现平台特点
SelectorEventLoop跨平台使用select/poll/epoll
ProactorEventLoopWindows使用IOCP
uvloopLinux/macOS高性能第三方实现

2.3 使用uvloop提升性能

import asyncio
import uvloop

# 使用uvloop替换默认事件循环
uvloop.install()

async def main():
    print("Running on uvloop")

asyncio.run(main())

三、协程调度机制

3.1 协程状态机

协程有四种状态:

  • PENDING:初始状态
  • RUNNING:正在执行
  • FINISHED:执行完成
  • CANCELLED:被取消
import asyncio

async def my_coroutine():
    try:
        while True:
            await asyncio.sleep(1)
            print("Running...")
    except asyncio.CancelledError:
        print("Cancelled!")
        raise

async def main():
    task = asyncio.create_task(my_coroutine())
    await asyncio.sleep(3)
    task.cancel()  # 取消任务
    try:
        await task
    except asyncio.CancelledError:
        print("Task was cancelled")

asyncio.run(main())

3.2 任务调度策略

asyncio使用协作式调度,协程必须主动让出控制权:

async def compute():
    # 计算密集型任务会阻塞事件循环
    result = 0
    for i in range(10**7):
        result += i
    return result

async def io_task():
    print("Starting IO task")
    await asyncio.sleep(0.1)
    print("IO task completed")

async def main():
    # 计算任务会阻塞IO任务
    compute_task = asyncio.create_task(compute())
    io_task = asyncio.create_task(io_task())
    
    await compute_task
    await io_task

asyncio.run(main())

3.3 解决计算密集型任务阻塞问题

import asyncio
from concurrent.futures import ThreadPoolExecutor

async def compute():
    loop = asyncio.get_event_loop()
    with ThreadPoolExecutor() as pool:
        # 在线程池中执行计算密集型任务
        result = await loop.run_in_executor(pool, heavy_compute)
    return result

def heavy_compute():
    result = 0
    for i in range(10**7):
        result += i
    return result

async def main():
    result = await compute()
    print(f"Result: {result}")

asyncio.run(main())

四、并发模式

4.1 并行执行多个任务

async def fetch(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1)
    return f"Result from {url}"

async def main():
    urls = [
        "https://api.example.com/1",
        "https://api.example.com/2",
        "https://api.example.com/3"
    ]
    
    # 使用gather并发执行
    results = await asyncio.gather(*[fetch(url) for url in urls])
    print(results)

asyncio.run(main())

4.2 带超时的任务执行

async def long_running_task():
    await asyncio.sleep(5)
    return "Done"

async def main():
    try:
        result = await asyncio.wait_for(long_running_task(), timeout=2)
        print(result)
    except asyncio.TimeoutError:
        print("Task timed out")

asyncio.run(main())

4.3 任务优先级控制

async def high_priority():
    print("High priority task started")
    await asyncio.sleep(0.1)
    print("High priority task completed")

async def low_priority():
    print("Low priority task started")
    await asyncio.sleep(1)
    print("Low priority task completed")

async def main():
    # 先启动低优先级任务
    low = asyncio.create_task(low_priority())
    await asyncio.sleep(0.01)  # 让低优先级任务开始
    
    # 启动高优先级任务
    high = asyncio.create_task(high_priority())
    
    await high
    await low

asyncio.run(main())

五、异步IO操作

5.1 文件操作

async def read_file(path):
    loop = asyncio.get_event_loop()
    with open(path, 'r') as f:
        # 使用线程池执行阻塞IO
        content = await loop.run_in_executor(None, f.read)
    return content

async def main():
    content = await read_file('example.txt')
    print(content)

asyncio.run(main())

5.2 网络操作

import asyncio
import aiohttp

async def fetch_with_aiohttp(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    content = await fetch_with_aiohttp('https://www.python.org')
    print(content[:500])

asyncio.run(main())

5.3 数据库操作

import asyncio
import asyncpg

async def query_database():
    conn = await asyncpg.connect('postgresql://user:pass@localhost/db')
    result = await conn.fetch('SELECT * FROM users LIMIT 10')
    await conn.close()
    return result

async def main():
    users = await query_database()
    print(users)

asyncio.run(main())

六、实战:构建异步Web服务

6.1 使用FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def heavy_computation():
    await asyncio.sleep(1)
    return {"result": 42}

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

@app.get("/compute")
async def compute():
    return await heavy_computation()

6.2 WebSocket支持

from fastapi import FastAPI, WebSocket
import asyncio

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Message received: {data}")
        await asyncio.sleep(0.1)

6.3 中间件实现

import asyncio
from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = asyncio.get_event_loop().time()
    response = await call_next(request)
    duration = asyncio.get_event_loop().time() - start_time
    print(f"Request took {duration:.2f} seconds")
    return response

七、性能优化技巧

7.1 避免阻塞调用

# 错误:阻塞事件循环
async def bad_example():
    import time
    time.sleep(1)  # 阻塞!

# 正确:使用异步版本
async def good_example():
    await asyncio.sleep(1)  # 非阻塞

7.2 批量操作优化

async def process_items(items):
    # 分批处理
    batch_size = 100
    for i in range(0, len(items), batch_size):
        batch = items[i:i+batch_size]
        tasks = [process_item(item) for item in batch]
        await asyncio.gather(*tasks)

7.3 连接池管理

import asyncpg
from typing import List

class DatabasePool:
    def __init__(self, dsn: str, min_size: int = 5, max_size: int = 20):
        self.dsn = dsn
        self.min_size = min_size
        self.max_size = max_size
        self.pool = None
    
    async def init(self):
        self.pool = await asyncpg.create_pool(
            dsn=self.dsn,
            min_size=self.min_size,
            max_size=self.max_size
        )
    
    async def query(self, sql: str, *args):
        async with self.pool.acquire() as conn:
            return await conn.fetch(sql, *args)

八、从Python到Rust的异步迁移

8.1 asyncio vs Tokio对比

特性Python asyncioRust Tokio
运行时单线程事件循环多线程工作窃取
并发模型协程协程 + 线程池
性能较好接近原生
内存安全运行时检查编译时保证

8.2 代码对比

Python版本:

import asyncio

async def fetch(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    results = await asyncio.gather(
        fetch("url1"),
        fetch("url2"),
        fetch("url3")
    )
    print(results)

asyncio.run(main())

Rust版本:

use tokio;

async fn fetch(url: &str) -> String {
    println!("Fetching {}", url);
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    format!("Data from {}", url)
}

#[tokio::main]
async fn main() {
    let results = tokio::join!(
        fetch("url1"),
        fetch("url2"),
        fetch("url3")
    );
    println!("{:?}", results);
}

九、常见问题与解决方案

9.1 事件循环阻塞

# 问题:计算密集型任务阻塞事件循环
async def blocking_task():
    result = 0
    for i in range(10**8):
        result += i

# 解决方案:使用线程池
async def non_blocking_task():
    loop = asyncio.get_event_loop()
    with ThreadPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, heavy_compute)
    return result

9.2 协程泄漏

# 问题:忘记await任务
async def main():
    task = asyncio.create_task(long_running())
    # task被丢弃,可能导致资源泄漏

# 解决方案:确保await所有任务
async def main():
    task = asyncio.create_task(long_running())
    await task

9.3 递归深度限制

# 问题:协程递归过深
async def recursive(n):
    if n == 0:
        return 0
    return n + await recursive(n - 1)

# 解决方案:使用循环替代递归
async def iterative(n):
    result = 0
    for i in range(n + 1):
        result += i
    return result

十、总结

asyncio是Python异步编程的核心库,通过事件循环、协程和任务实现高效的并发编程。关键要点包括:

  1. 事件循环:负责调度协程和处理IO事件
  2. 协程:轻量级的并发原语
  3. 任务:协程的并发包装器
  4. 并发模式:gather、wait_for、join等
  5. 性能优化:避免阻塞、使用线程池、批量操作

通过掌握asyncio,你可以构建高性能的异步应用,为后续学习Rust异步编程打下坚实基础。


参考资料:

Python的可等待对象在Asyncio的作用 在深入了Task,Future的源码了解后,了解了Task和Future在Asyncio的作用,同时也发现Task和Future都跟loop有一定的耦合,而loop也可以通过一定的方法来创建Task和Future,所以如果要真正的理解到Asyncio的调度原理,还需要更进入一步,通过Asyncio的源码来了解整个Asyncio的设计. 阅读详情

相关推荐

Anaconda下安装LabelImg

Anaconda下安装LabelImg

LYH8543的博客 758

Python异步编程:深入理解事件循环与协程

while True : # 1. 检查有哪些任务可以执行 # 2. 执行这些任务 # 3. 如果任务需要等待(如网络请求),就切换到其他任务 # 4. 检查之前等待的任务是否完成 # 5. 重复以上过程fill:#333;单线程任务1任务2任务3任何时刻只能执行一个任务执行遇到I/O操作await (必须让出!切换到下一个任务执行遇到I/O操作await (必须让出!执行CPU密集计算如果T3不让出,T1和T2永远无法继续!单线程任务1任务2任务3mindmap。

ningyanggege的博客 1213

Android音频混音器AudioMixer实战:从多路输入到设备播放的完整流程解析

本文深入解析了Android平台上音频混音器AudioMixer的完整工作流程,涵盖从多路音频输入、轨道创建与配置、AudioBufferProvider数据源接入,到核心混音处理与最终设备播放的全过程。文章重点探讨了如何高效管理音频数据流、配置音量与重采样参数,并提供了缓冲区管理与性能优化的实战技巧,帮助开发者构建稳定、低延迟的音频应用。

l3m4n的博客 342

python协程详解

协程的核心思想就在于执行者对控制流的“主动让出”和“恢复”。相对于,线程此类的“抢占式调度”而言,协程是一种“协作式调度”方式。

piliang719719的博客 893

正直摄影方式的精度估算式_利用BDS数据反演大气可降水量及其精度分析

可降水量(PWV)对中小尺度灾害性天气预报具有指示意义,是降雨强度预报的重要参数之一。自20世纪80、90年代起,国外已经对GPS探测大气可降水量进行了大量研究。国内最早由毛节泰引进并详细介绍了地基GPS反演大气可降水量的方法,近年来发展迅速并取得了一定的成果。随着中国北斗卫星导航系统(BDS)提供服务并不断地建设完善,其已经能够应用到气象学领域,可以获得大气可降水量。文献[11]利用...

weixin_39796752的博客 1246

ENVI5.6 自动化流程:GF系列卫星影像批处理与质量优化

本文详细介绍了如何利用ENVI5.6构建针对GF-2、GF-6、GF-7系列卫星影像的自动化批处理流水线。通过配置Batch Processing工具,实现从正射校正到图像融合的全流程批量处理,并分享参数设置、质量监控与故障排查的实战经验,旨在显著提升海量遥感影像的处理效率与成果质量。

efc1234567的博客 604

Python 协程完全指南:从事件循环到底层原理

本文全面解析了Python协程的核心概念和底层原理,从事件循环的工作机制到async/await的实现原理,详细讲解了协程、任务、Future等关键组件。文章涵盖了协程状态机、异步上下文管理、性能优化等高级主题,并提供了常见问题的解决方案和最佳实践指南。

YAnt的博客 1231

SWMM建模与案例应用

4、排水系统控制规则通过控制功能,可以在模拟进行过程中,通过条件判断,对闸门、水泵、管道、孔口、堰进行控制,实现排水系统实时控制。5、SWMM与其他模型对比分析分析:STORM、MOUSE、Info Works、SUSTAIN、SWC。1、模型初始设置主要参数:雨量计、汇水区、节点、出水口、管渠、分流器、蓄水池等参数前缀的设置。2、气象数据设置温度、蒸发、风速、融雪、面积亏损、气候调整、雨量计。1、多软件数据交互:CAD、Arcgis、SWMM。(1)节点、管段、水泵、孔口、堰、雨水口和街道。

m0_74575633的博客 3424

Python 异步架构详解:事件循环(event loops)、任务(tasks)、协程(coroutines)与 Future

本文深入解析了Python asyncio库的核心组件:事件循环、任务和Future。事件循环作为调度中心,负责管理多个任务的执行;任务(Task)是协程的包装器,实现并发执行;Future则是表示异步操作结果的底层对象。文章通过代码示例演示了如何创建任务、处理并发、错误处理和超时控制,并对比了任务与Future的区别。最后介绍了高级用法如asyncio.gather()和事件循环替代实现(如uvloop)。理解这些核心概念有助于编写高效可靠的异步Python代码。

yuzhu168的博客 489

LabVIEW工程密码保护机制与移除技术详解

LabVIEW作为工业自动化领域广泛使用的图形化编程工具,其密码保护机制涉及文件加密与权限控制等核心技术。从技术实现来看,现代版本采用AES-128加密结合SHA-256哈希校验,而经典版本使用XOR加密配合Base64编码。理解这些加密原理对于工程维护、灾难恢复等合法场景至关重要。在实际应用中,密码移除工具需要处理不同版本的文件结构差异,包括解析XML描述区的Protection标签、动态识别版本并应用对应解密策略。这类技术在工业设备维护、教学研究等场景具有重要价值,但必须注意遵守法律边界,确保拥有合法的

weixin_34161083的博客 392

win10解决IE浏览器安装不上的问题(卸载依然显示不能安装)

目前win10 系统不支持外部ie安装程序,所以必须用win10自带的应用来安装 一、错误的卸载的方式 在控制面板的当前安装的程序界面是看不到ie的,需要选择控制面板左上角的启用或关闭windows功能 将ie11前面的勾勾去掉 这种方法是很多网站上的误区,其实这并没有卸载成功ie只是把ie的功能关闭了,但是他还在你的电脑上。你可以理解为我们说的对文件夹执行的隐藏文件夹功能。那个隐藏的文件夹依...

清平乐的技术专栏 3万+

深入理解Python协程:asyncio、异步并发、事件循环

精讲 Python 异步协程、事件循环等核心概念,剖析 asyncio 库在不同系统的事件循环机制,通过网络请求、数据库操作等实战案例,展现其在 I/O 密集型场景减少阻塞、提升并发效率的优势。

weixin_54217348的博客 1412

Android功耗系列专题理论之六:外设功耗问题分析方法

本文介绍了移动设备功耗问题的分析方法,重点针对传感器和GPU两大模块。传感器部分详细讲解了通过ADB命令获取日志、状态差异分析和单传感器隔离测试的排查方法,并给出优化建议。GPU部分从基础功耗测量、场景测试到功能模块拆解进行多维度分析。同时阐述了GNSS/GPS功耗的测试方法,包括前后台对比、星座双频拆解及SAP/DPO等特殊功能的电流分析,为移动设备功耗优化提供系统性的诊断思路。

377

深入解析Python asyncio:从事件循环到协程调度实战

在IO密集和高并发场景下,Python程序的性能瓶颈往往来自等待IO的阻塞,而异步编程正是解决这类问题的关键范式。asyncio作为Python生态中最核心的异步编程库,通过事件循环与协程调度机制,在单线程内实现了高效的并发任务处理。理解其底层原理——从协程对象到Task的包装,从await挂起到信号量限流——是驾驭复杂异步项目的基石。无论是网络爬虫、Web服务还是消息消费者,掌握asyncio都能显著提升资源利用率和并发能力。文章从同步代码的困境出发,逐步拆解asyncio的事件循环、协程、Future等

weixin_30231327的博客 320

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

python | Python协程调度:asyncio事件循环

Python的异步编程模型为处理I/O密集型任务提供了高效的解决方案。在众多并发编程方法中,asyncio库以其简洁的语法和强大的功能脱颖而出。本文将深入探讨Python协程调度机制和asyncio事件循环的工作原理,帮助开发者更好地理解和应用异步编程技术。

csdn_xmj的博客 1461

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Python(29)Python生成器函数深度解析:asyncio事件循环的底层实现与异步编程实战

本文深入解析Python 3.12中生成器与asyncio事件循环的协同机制,揭示了异步编程的核心原理。从生成器基础特性、协程进化历程入手,剖析事件循环架构和调度流程,详细讲解生成器双向通信、异常处理等高级特性。通过性能优化实测展示内存管理与执行效率提升技巧,并提供代码组织规范和调试建议。结合CPython源码分析,为开发者提供从底层原理到工程实践的完整指南,帮助编写高效可靠的异步Python代码。

优快云博客专家,领域包括但不限于:AI、大数据、Python、架构师,有合作、课程、问题、疑惑请私信博主 1万+

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

运筹帷幄决胜千里,Python3.10原生协程asyncio工业级真实协程异步消费任务调度实践

我们一直都相信这样一种说法:协程是比多线程更高效的一种并发工作方式,它完全由程序本身所控制,也就是在用户态执行,协程避免了像线程切换那样产生的上下文切换,在性能方面得到了很大的提升。毫无疑问,这是颠扑不破的业界共识,是放之四海而皆准的真理。...

刘悦的技术博客 1413

Python 生成器函数深度解析:asyncio 事件循环的底层实现与异步编程实战

本文深入探讨了Python中生成器函数与asyncio事件循环的协同机制,解析异步编程的核心原理。文章首先介绍生成器的基础概念及其迭代协议,揭示其作为惰性计算的优势;随后详细阐述asyncio事件循环的工作机制,说明协程如何通过await实现任务切换;重点分析生成器与异步编程的结合方式,包括异步生成器的实现原理及在事件循环中的调度过程;最后通过自定义任务调度器的实例,展示如何利用生成器构建高效的异步任务队列。全文从底层实现到高级应用,为开发高性能Python并发程序提供了系统性的技术指导。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1257

定时执行python_Python线程、协程探究(3)——协程的调度实现

前言的前言同学们,别光点赞收藏,记得关注我的专栏哦,每周都有更新!前言这篇文章我们再次回到协程。协程的技术实际上是非常重要的,比如微信的后台就大量的使用协程来进行并发量的提高,只用多线程和多进程很难低成本、高效地满足全球数十亿用户的各种操作请求。协程的底层实现可以定制的,微信团队就开源了一个他们实现的协程库。直接分析他们的实现比较困难,所以我们先分析python官方的协程库asyncio的底层实现...

weixin_39991935的博客 618

Python asyncio 的事件循环机制解析

事件循环是一个无限循环,它不断地检查是否有需要处理的任务,并根据优先级和顺序执行这些任务。在 asyncio 中,事件循环负责调度协程、处理 I/O 操作和其他异步操作。通过本文的介绍,我们可以看到,事件循环是 asyncio 库的核心概念之一,它负责调度协程、处理 I/O 操作和其他异步操作。理解事件循环的工作原理,可以帮助我们更好地使用 asyncio 库,编写出高效、可靠的异步代码。```

2501_90728490的博客 441

python---异步IO(asyncio)协程

python---异步IO(asyncio)协程 目录 简单了解定义一个协程(不同于上面的实例)创建一个任务(对协程进一步封装,可以查看状态等)绑定回调add_done_callback我也可以不使用回调函数,单纯获取返回值阻塞和await并发:使用gather或者wait可以同时注册多个任务,实现并发协程嵌套,将多个协程封装到一个主协程中协程停止上面讨论的都是在同一线程下的事件循环,下...

671

Python 协程原理、asyncio 调度机制与 Task 生命周期全解析

本文详细介绍了Python协程的本质及其演进历程。协程是一种可暂停和恢复执行的轻量级并发单元,相比线程具有更低的开销。文章梳理了Python协程发展的三个阶段:生成器协程(yield)、委托协程(yield from)和原生协程(async/await)。重点讲解了async/await语法的工作原理、协程对象与await协议的关系,以及asyncio事件循环的调度机制。通过示例说明了Task的生命周期和典型的异步编程模式,比较了create_task与gather的区别。最后指出协程适用于IO密集型场景,

qq_24208545的专栏 1323

python--协程--asyncio

(Coroutine)是一种程序组件,它允许在单个线程内实现。你可以把它理解为一种更轻量级的“线程”,但与操作系统管理的线程不同,,而不是由操作系统内核抢占式调度。

m0_60274660的博客 455

Python异步编程:asyncio与协程深度解析

Python异步编程是一种高效处理I/O密集型任务(如网络请求、文件读写)的范式,它通过协程(coroutine)和事件循环(event loop)避免传统线程的上下文切换开销。本解析将从基础概念入手,逐步深入asyncio库的内部机制,涵盖协程原理、事件循环调度、任务管理,并提供实用代码示例。数学建模:事件循环的吞吐量可表示为$ \text{Throughput} = \frac{N}{T_{\text{avg}}} $,其中$N$为并发任务数,$T_{\text{avg}}$为平均任务时间。

2501_93893344的博客 736

python中协程与函数的区别_python协程 yield和yield_from的区别

面试被问到python3 的asyncio模块、python2中的yield和yield from的区别面的第一家觉得回答的不是很好, 回来进行收集整理一番,以便巩固记忆Python中的协程大概经历了三个阶段:最初的生成器变形yield/send引入@asyncio.coroutine和yield from在最近的python3.5版本中引入async/await字段下面将对上边的三个阶段进行说明...

weixin_39724469的博客 121
上一篇: Rust Trait系统设计模式:实现灵活的多态和代码复用
下一篇: Rust 服务网格实战:用 Linkerd2 构建现代化微服务架构
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值