Python异步编程学习笔记

最新推荐文章于 2023-11-25 21:53:56 发布
最新推荐文章于 2023-11-25 21:53:56 发布
阅读量295 收藏 3
点赞数 1
分类专栏： Python编程技巧 python基础必备知识 文章标签： python 异步编程 协程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoduu/article/details/108313286
版权

文章目录

Python异步编程学习笔记

  • 参考文章：https://www.bilibili.com/video/BV1dD4y127bD?p=2

  • 为什么要讲异步编程

    • 异步非阻塞、asyncio
    • tornado、fastapi、django 3.x asgi、aiohttp都在异步 ->提升性能

  • 如何讲解

    • 协程
    • asyncio模块进行异步编程
    • 实战案例

1 协程

协程不是计算机提供，而是程序员人为创造，是一种运行方式

协程（Coroutine），也可以被称为微线程，是一种用户态内的上下文切换技术。简而言之，其实就是通过一个线程实现代码块间的相互切换并执行。例如：

def func1():
    print(1)
    ...
    print(2)

def func2():
    print(3)
    ...
    print(4)

func1()
func2()
# 程序在func1于func2之间来回切换执行，使得结果输入为1 3 2 4

实现协程有那么几种方法：

  • greenlet，早期第三方模块
  • yield关键字
  • asyncio装饰器（py3.4提供的内置模块）
  • async、await关键字（py3.5提供的用于代替简化asyncio的关键字）（推荐使用）

1.1 greetlet实现协程

pip install greenlet

from greenlet import greenlet

def func1():
    print(1)        # 第1步：输出1
    gr2.switch()    # 第2步，切换到gr2对应的func2函数
    print(2)        # 第5步，输出2
    gr2.switch()    # 第6步，切换到func2

def func2():
    print(3) # 第3步：输出3
    gr1.switch() # 第4步，切换到func1函数
    print(4) # 第7步，输出4


gr1 = greenlet(func1)
gr2 = greenlet(func2)

gr1.switch() # 第1步：去执行func1函数
# 输出结果为1 3 2 4

1.2 yield关键字

def func1():
    yield 1                 # 第1步：输出1
    yield from func2()      # 第2步，切换到func2函数
    yield 2                 # 第5步，输出2

def func2():
    yield 3 			# 第3步：输出3
    yield 4 			# 第4步，输出4


f1 = func1()
for item in f1:
    print(item)
    
# 注意：yield的切换是从函数开头开始
# 输出结果为1 3 2 4

1.3 asyncio装饰器

在python3.4及之后的版本

import asyncio


@asyncio.coroutine
def func1():
    print(1)
    # ... 这里可以写网络IO请求的代码
    yield from asyncio.sleep(2)  # 遇到IO耗时操作时，等待两秒，这时程序会自动切换到tasks中的其他任务，两秒过后会继续从当前代码行向下执行
    print(2)


@asyncio.coroutine
def func2():
    print(3)
    # ... 这里可以写网络IO请求的代码
    yield from asyncio.sleep(2)  # 遇到IO耗时操作时，等待两秒，这时程序会自动切换到tasks中的其他任务，两秒过后会继续从当前代码行向下执行
    print(4)


tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
# 输出结果为1 3 2 4

注意：遇到IO阻塞时自动切换任务

1.4 async、await关键字

在python3.5及之后的版本

async和await关键字的推出是为了简化asyncio的操作，本质还是和asyncio一样

使用async代替@asyncio.coroutine，使用await代替yield from

import asyncio
async def func1():
    yield 1
    await asyncio.sleep(2)
    yield 2

async def func2():
    yield 3
    yield 4


tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
# 输出结果为1 3 2 4

2 协程意义

不等待IO执行结果。

在一个线程中一个任务遇到了IO等待的话，不等待IO结果，而直接去执行其他任务。

案例：下载三张图片（网络IO）

  • 普通方式下载图片

    • import requests
import time


def download_image(url):
    print('开始下载：', url)
    # 发送网络请求，下载图片
    response = requests.get(url)
    # 将图片保存到本地
    file_name = url.split('@')[0].rsplit('/')[-1]
    with open(file_name, 'wb') as file_object:
        file_object.write(response.content)
    print('下载完成')


if __name__ == '__main__':
    url_list = 			['https://i0.hdslb.com/bfs/archive/edf302b33b922c19c25abcfd751f12ba81f8155f.jpg@880w_388h_1c_95q',             'https://i0.hdslb.com/bfs/archive/d42643d17e3e12075a805217cbd3458258c38b57.png@880w_388h_1c_95q',             'https://i0.hdslb.com/bfs/archive/6a92aac791c1af80fb211145b4a5dc0e1541cbf7.jpg@880w_388h_1c_95q']
    start = time.time()
    for item in url_list:
        download_image(item)
    end = time.time()
    print(end - start)

  • 协程方式下载图片

    • import aiohttp
import asyncio
import time


async def fetch(session, url):
    print('发送请求：', url)
    async with session.get(url, verify_ssl=False) as response:
        content = await response.content.read()
        file_name = url.split('@')[0].rsplit('/', 1)[-1]
        with open(file_name, mode='wb') as file_object:
            file_object.write(content)
    print('下载完成')


async def main():
    async with aiohttp.ClientSession() as session:
        url_list = ['https://i0.hdslb.com/bfs/archive/edf302b33b922c19c25abcfd751f12ba81f8155f.jpg@880w_388h_1c_95q',
                    'https://i0.hdslb.com/bfs/archive/d42643d17e3e12075a805217cbd3458258c38b57.png@880w_388h_1c_95q',
                    'https://i0.hdslb.com/bfs/archive/6a92aac791c1af80fb211145b4a5dc0e1541cbf7.jpg@880w_388h_1c_95q']
        tasks = [asyncio.create_task(fetch(session, url)) for url in url_list]
        await asyncio.wait(tasks)


if __name__ == '__main__':
    start = time.time()
    asyncio.run(main())
    end = time.time()
    print(end - start)

3 异步编程

3.1 事件循环

事件循环可以理解为成一个死循环，该死循环内的功能是不断的检测任务的状态并执行不同的操作，

理解为一个空间，该空间的功能是对放入该空间的任务不断地检测并执行

# 伪代码

任务列表 = [任务1, 任务2, 任务3, ...]

while True:
    可执行的任务列表，已完成的任务列表 = 去任务列表中检查所有的任务，将‘可执行’和‘已完成’的任务返回
    
    for 就绪任务 in 可执行的任务列表：
    	执行已就绪的任务
    
    for 已完成的任务 in 已完成的任务列表：
    	在任务列表中移除 已完成的任务
    
    如果 任务列表中的任务都已经完成即没有任务了，则终止循环

import asyncio

# 去生成或获取一个事件循环
loop = asyncio.get_event_loop()

# 将任务放到 `任务列表`
loop.run_until_complete(任务)

3.2 快速上手

协程函数，定义函数时候async def 函数名

协程对象，执行协程函数()得到的协程对象

async def func():
	pass

result = func()

注意：执行协程函数创建协程对象，函数内部代码不会执行

想要去运行协程函数内部代码，需要将协程对象交给事件循环来处理。

import asyncio

async def func():
    print('冲冲冲')

result = func()

#loop = asyncio.get_event_loop()
#loop.run_until_complete( result )
asyncio.run(result) # python3.7只需要这一句就可以实现上面两句功能

3.3 await

await + 可等待的对象（协程对象、Future、Task对象 -> IO等待）

示例1：

import asyncio

async def func():
    print('来玩呀')
    response = await asyncio.sleep(2)
    print('不玩了')

asyncio.run(func()) # 将协程对象传入事件循环中运行

示例2：

import asyncio

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return '返回值'

async def func():
    print(’执行协程函数内部代码) 		# 第2步
    # 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
    response = await others() 	# 第3步 去执行其他的异步函数，一直等待直到等到结果返回
    print('IO请求结束，结果为：', response)

asyncio.run(func()) # 第1步，将协程对象传入事件循环

示例3：

import asyncio

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return '返回值'

async def func():
    print(’执行协程函数内部代码)
    # 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
    response1 = await others() # 在这个func函数中一直等待，直到得到others函数返回值，才继续往下执行
    print('IO请求结束，结果为：', response1)
    
    response2 = await others()
    print('IO请求结束，结果为：', response2)

asyncio.run(func())

await就是等待，等到对象返回结果之后才继续往下走。

3.4 Task对象

Tasks are used to schedule coroutines concurrently.

When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon.

白话：Task对象就是将任务添加到事件循环中去或在事件循环中添加多个任务。

Tasks用于并发调用协程，通过asyncio.create_task(协程对象) 的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用asyncio.create_task()函数以外，还可以用低层级的loop.create_task() 或 asyncio.ensure_future 函数。不建议手动实例化Task对象

注意：asyncio.create_task() 函数在Python 3.7中被加入。在Python 3.7 之前，可以改用低层级的asyncio.ensure_future() 函数。

示例1：

import asyncio

async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'

async def main():
    print('main开始')

    # 创建Task对象，将当前执行的func函数添加到事件循环中
    task1 = asyncio.create_task(func())
    # 同上，这里create_task函数只是将func函数添加到事件循环中，并不会执行内部代码
    task2 = asyncio.create_task(func())
    print('main结束')

    # 当事件循环中的任务遇到IO操作时，才会自动化切换执行其他任务
    # 此处的await是等待相对应的协程全部执行完毕并获取结果
    ret1 = await task1
    ret2 = await task2
    print(ret1,ret2)

asyncio.run( main() )

示例2：

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'


async def main():
    print('main开始')
    task_list = [
        asyncio.create_task(func()),
        asyncio.create_task(func())
    ]
    print('main结束')
    done, pending = await asyncio.wait(task_list, timeout=1)
    print('done:', done)
    print('pending:', pending)


asyncio.run(main())

示例3：

import asyncio

async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'

task_list = [
    func(),
    func()
]

done,pending = asyncio.run(asyncio.wait(task_list))
print(done)
for d in done:
    print(d.result())

3.5 asyncio.Future对象

A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation.

Task继承Future，Task对象内部await结果的处理是基于Future对象来的

await 这个关键字功能是一直等待await后面的对象执行完获取到对应的结果，这个一直等待就相当于一个夯住过程，而await关键字是如何实现夯住直到获取到结果的过程呢，其实是通过future对象来实现的。

示例1：

async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()
    
    # 创建一个任务(Future对象)，将这个任务添加进事件循环，这个任务什么都不干
    fut = loop.create_future()
    
    # 等待任务最终结果（Future对象），没有结果则会一直等待下去
    await fut

asyncio.run( main() ) # 这里已经创建了事件循环，并将main函数添加进去并执行

示例2：

import asyncio

async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result('666') # 给fut对象赋值

async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()
    
    # 创建一个任务(Future对象)，将这个任务添加进事件循环，这个任务什么都不干
    fut = loop.create_future()
    
    # 创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后会给fut赋值。
    # 即手动设置了future任务的最终结果，那么fut对象被赋值后有值了，await fut就会结束
    await loop.create_task( set_after(fut) )
    
    # 等待任务最终结果（Future对象），没有结果则会一直等待下去
    data = await fut
	print(data)
    
    
asyncio.run( main() ) # 这里已经创建了事件循环，并将main函数添加进去并执行

3.6 concurrent.futures.Future对象

使用线程池、进程池实现异步操作时用到的对象

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor


def func(value):
    time.sleep(1)
    print(value)


# 创建线程池
pool = ThreadPoolExecutor(max_workers=5)

# 创建进程池
# pool = ProcessPoolExecutor(max_workers=5)

for i in range(10):
    fut = pool.submit(func, i)
    print(fut)

以后写代码可能会存在交叉使用协程和线程/进程。例如：crm项目80%都是基于协程异步编程 ,假设第三方数据库不支持协程async和await来做异步编程，那么第三方数据库工具就需要使用线程、进程做异步编程。

即可以理解为第三方数据库模块使用concurrent.futures.Future对象来做的异步编程，我们需要将这个Future对象转换成asycio.Future对象来融合到crm项目中（因为crm是基于协程来进行异步编程的，协程使用的是asycio.Future对象）。

import time
import asyncio
import concurrent.futures


def func1():
    # 某个耗时操作
    time.sleep(2)
    return '666'


async def main():
    loop = asyncio.get_running_loop()

    # 1. Run in the default loop's executor(默认 ThreadPoolExecutor)
    # 第1步：内部会先调用 TreadPoolExecutor 的 submit 方法去线程池中申请一个线程去执行func1函数，并返回一个concurrent.futures.Future对象
    # 第2步：run_in_executor内部会调用asyncio.wrap_future将concurrent.futures.Future对象包装为asyncio.Future对象。
    # 因为concurrent.futures.Future对象不支持await语法，所以需要包装为asyncio.Future对象才能使用。

    # 注意这里的func1不是协程函数，这里的func1函数相当于第三方数据库函数，它本身不支持协程异步而且它是IO操作的话，就需要使用run_in_executor方法将它变成asyncio.Future对象，变成asyncio.Future对象后就可以使用await去等待，去异步执行这个func1函数
    fut = loop.run_in_executor(None, func1)
    result = await fut
    print('default thread pool', result)

    # 2. Run in a custom thread pool:
    # with concurrent.futures.ThreadPoolExecutor() as pool:
    #     result = await loop.run_in_executor(pool, func1)
    #     print('custom thread pool', result)

    # 3. Run in a custom process pool:
    # with concurrent.futures.ProcessPoolExecutor() as pool:
    #     result = await loop.run_in_executor(pool, func1)
    #     print('custom process pool', result)


asyncio.run(main())

3.7 异步迭代器

普通迭代器：实现了__iter__()和__next__()，__iter__()用于返回迭代器示例本身self，__next__用于共同完成迭代器的迭代功能。

普通可迭代器对象：必须实现__iter__()，但不能实现__next__()，__iter__()用于实例化一个迭代器对象，即返回一个迭代器。

异步迭代器：实现了__aiter__()和__anext__() 方法的对象。__anext__ 必须返回一个awaitable对象。async for会处理异步迭代器的__anext__()方法所返回的可等待对象，直到其引发一个StopAsyncIteration异常。

异步可迭代对象：可在async for语句中被使用的对象。必须通过它的__aiter__()方法返回一个asynchronous iterator。

import asyncio

class Reader(object):
    """ 自定义异步迭代器（同时也是异步可迭代对象）"""
    
    def __init__(self):
        self.count = 0
    
    async def readline(self):
        # await asyncio.sleep(1)
        self.count += 1
        if self.count == 100:
            return None
       	return self.count
    
    def __aiter__(self):
        return self
    
    async def __anext__(self):
        val = await self.readline()
        if val == None:
            raise StopAsyncIteration
        return val

async def func():
    obj = Reader()
    async for item in obj:
        print(item)
       
asyncio.run( func() )

注意：async for 语句只能在协程函数里面使用

3.8 异步上下文管理器

此种对象是通过定义__aenter__()和__aexit__()方法来对async with语句中的环境进行控制。

示例：可以在操作数据库前后通过上下文管理器完成连接数据库操作和关闭连接操作。

import asyncio

class AsyncContextManager:
    def __init__(self,conn):
        self.conn = conn

    async def do_something(self):
        # 异步操作数据库
        return 666

    async def __aenter__(self):
        # 异步连接数据库
        self.conn = await asyncio.sleep(1)
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # 异步关闭数据库连接
        await asyncio.sleep(1)

async def func():
    async with AsyncContextManager('xxx') as f:
        result = await f.do_something()
        print(result)

asyncio.run( func() )

4 uvloop

uvloop是asyncio的事件循环的替代方案。asyncio的事件循环的效率 < uvloop。

pip3 install uvloop

import asyncio
import uvloop
# 要使用uvloop替代asyncio内部的事件循环，只需要设置一下即可
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

# 其他异步操作不变，编写的asyncio代码和之前写的一样

# 内部的事件循环会自动变成uvloop
asyncio.run(xxx)

usgi：web server gateway interface（web服务网关接口）

asgi：async server gateway interface（异步服务网关接口）

wsgi、uwsgi、asgi了解：https://www.cnblogs.com/f-g-f/p/11294559.html

注意：一个非常块的asgi是：uvicorn，fastapi框架中的asgi就是使用uvicorn，而uvicorn内部的事件循环是使用uvloop。

5 实战案例

5.1 异步redis

在使用python代码操作redis时，链接/操作/断开都是网络IO操作，所以可以用异步提高性能。

pip3 install aioredis

示例1：

import asyncio
import aioredis


async def execute(addr, passw=None):
    print('开始执行', addr)
    # 网络IO操作：创建redis连接
    redis = await aioredis.create_redis(addr)

    # 网络IO操作：在redis中设置哈希值car，内部再设置三个键值对，即：redis = {'car':{'key1':1, 'key2':2, 'key3':3 }}
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)

    # 网络IO操作：去redis中获取值
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)

    redis.close()
    # 网络IO操作：关闭redis连接
    await redis.wait_closed()
    print('结束', addr)


asyncio.run( execute('redis://localhost:6379') )

示例2：

import asyncio
import aioredis


async def execute(address, password=None):
    print('开始执行', address)

    # 网络IO操作：先去连接47.93.4.197:6379，遇到IO则自动切换任务去连接47.93.4.198:6379
    redis = await aioredis.create_redis_pool(address, password=password)

    # 网络IO操作：遇到IO会自动切换任务
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)

    # 网络IO操作：遇到IO会自动切换任务
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)

    redis.close()
    # 网络IO操作：遇到IO会自动切换任务
    await redis.wait_closed()

task_list = [
    execute('redis://47.93.4.197:6379', 'root!123'),
    execute('redis://47.93.4.198:6379', 'root!123'),
]

asyncio.run(asyncio.wait(task_list))

5.2 异步mysql

pip install aiomysql

示例1：

import aiomysql
import asyncio


async def execute(host, password):
    # 网络IO操作：连接mysql
    conn = await aiomysql.connect(host=host, port=3306, user='root', password=password, db='db4')

    # 网络IO操作：创建CURSOR
    cur = await conn.cursor(aiomysql.cursors.DictCursor)

    # 网络IO：执行SQL
    await  cur.execute('select * from book')
    result = cur.fetchall()
    print(result)

    # 网络IO：关闭连接
    await cur.close()
    conn.close()


asyncio.run(execute('127.0.0.1','root'))

示例2：

import aiomysql
import asyncio


async def execute(host, password):
    # 网络IO操作：连接mysql,先去连接192.168.1.10，遇到IO则自动切换去连接192.168.1.11
    conn = await aiomysql.connect(host=host, port=3306, user='root', password=password, db='db4')

    # 网络IO操作：创建CURSOR
    cur = await conn.cursor(aiomysql.cursors.DictCursor)

    # 网络IO：执行SQL
    await  cur.execute('select * from book')
    result = cur.fetchall()
    print(result)

    # 网络IO：关闭连接
    await cur.close()
    conn.close()


tasks = [
    execute('192.168.1.10', 'root'),
    execute('192.168.1.11', 'root1')
]
asyncio.run(asyncio.wait(tasks))

5.3 FastAPI框架异步

需要安装FastAPI

pip3 install fastapi

pip3 install uvicorn (一个asgi，内部是基于uvloop)

示例：FastAPI.py

import asyncio
import aioredis
from aioredis import Redis
import fastapi
import uvicorn

app = FastAPI()

# 创建一个redis池
REDIS_POOL = aioredis.ConnectionsPool('redis://192.168.1.10:6379', password='root', minsize=1, maxsize=10)


@app.get('/')
def index():
    '''普通操作接口'''
    return {'message': 'Hello world'}


@app.get('/red')
async def red():
    '''异步操作接口'''
    print('请求来了')

    await asyncio.sleep(3)
    # 连接池获取一个连接
    conn = await REDIS_POOL.acquire()
    # 获取redis对象
    redis = Redis(conn)

    # 设置值
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)

    # 读取值
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)

    # 连接归还连接池
    REDIS_POOL.release(conn)

    return result


if __name__ == '__main__':
    uvicorn.run('FastAPI:app', host='127.0.0.1', port=5000, log_level='info')
    # FastAPI是这个文件的名字

注意：这里是使用FastAPI框架来实现，同样的其他支持asgi（异步服务网关接口）的框架也可以用这种方式来实现，不支持异步的框架，可以使用3.6节中提到的线程池或进程池配合协程异步来实现。

5.4 爬虫异步

pip3 install aiohttp

import aiohttp
import asyncio


async def fetch(session, url):
    print('发送请求：', url)
    async with session.get(url, verify_ssl=False) as response:
        text = await response.text()
        print('得到结果:', url, len(text))
        return text


async def main():
    async with aiohttp.ClientSession() as session:
        url_list = [
            'https://python.org',
            'https://www.baidu.com',
            'https://www.pythonav.com'
        ]
        task_list = [asyncio.create_task(fetch(session, url)) for url in url_list]
        done, pending = await asyncio.wait(task_list)


if __name__ == '__main__':
    asyncio.run(main())

总结

异步最大的意义：用最少的资源完成最多的事情。

通过一个线程利用其IO等待时间去做一个其他事情。

异步笔记总结：

  • 1 协程实现方式可以通过第三方工具greenlet或者python自带的功能，例如：yield关键字、asyncio装饰器、async和await关键字
  • 2 实现异步编程代码的流程
    • 2.1 了解事件循环的存在意义，事件循环相当于一个用于监控任务的存储空间，可以将异步任务放入事件循环中被监控与被执行
    • 2.2 因为现在我们使用的python版本都是3.7以上的了，所以经常会用async、await关键字去实现异步编程。
    • 2.3 注意async with语句和async for语句都需要在异步函数中才能生效
  • 3 了解其他框架支不支持异步实现，如果不支持的话则可以使用线程池或进程池来配合协程去实现异步，参考本文3.6章节
  • 4 多使用异步来提高执行效率
JTOOP
关注
专栏目录
python实现协程（六）
Geroge_lmx的博客
03-30 3477
本节介绍asyncio剩余的一些常用操作：事件循环实现无限循环任务，在事件循环中执行普通函数以及协程锁。 一. 无限循环任务 事件循环的run_until_complete方法运行事件循环时，当其中的全部任务完成后，会自动停止循环；若想无限运行事件循环，可使用asyncio提供的run_forever方法： import asyncio import ti...
从头造轮子：python3 asyncio之 run_until_complete （1）
管彤python每日分享python技巧
01-03 1640
今天开始聊一聊python3的asyncio。关于asyncio，大家肯定都有自己的理解，并且网上大神也把基础概念也解释的比较透彻。 本文写作的初衷，主要是理解asyncio的原理并且实现一遍。 话不多说，我们开始！ 一、知识准备 ● 理解进程、线程、协程。简单来说，这三个都是为了解决多任务同时进行的问题   1）进程是操作资源分配的最小单位，多任务的实现主要是极快地在进程间来回切换，而进程切换消耗时间最长（系统调用）   2）线程依赖于进程，多个线程共享了父进程的一部分资源，线程切换时间相对于进程来说
Python asyncio异步编程 学习笔记
积一时之步，臻千里之遥程
01-25 671
跟着武沛齐老师教程做的学习笔记 主要参考：https://pythonav.com/wiki/detail/6/91/ 课程链接（《asyncio异步编程》，讲师：武沛齐老师） 文章目录1 协程1.1 简介1.2 在Python中实现协程方式1.2.1 greenlet1.2.2 yield1.2.3 asyncio1.2.4 async & awit1.2.5 普通爬虫与协程爬虫1.2.5.1 普通爬虫（同步：按照顺序逐一排队执行）1.2.5.2 基于协程的异步编程实现（异步：遇到IO请求.
Python并发编程2
Hundreays
05-16 1138
Python并发编程25.协程5.1 协程的概念5.2 生成器函数—协程发展史5.3 协程的实现5.3.1 使用生成器yield实现5.3.2 greenlet实现协程5.3.3 gevent 实现协程5.3.4 Asyncio5.4 Asyncio模块5.4.1 重要概念和相关方法5.4.2 定义协程5.4.3 运行协程5.4.4 回调函数5.4.5 多个协程并行5.4.6 run_unti...
asyncio run_until_complete和run_forever运行对比
迷心兔的博客
10-08 2万+
原因：run_until_complete和run_forever运行对比， run_until_complete 来运行 loop ，等到 future 完成，run_until_complete 也就返回了。 run_forever 会一直运行，直到 stop 被调用 第一种运行方式 # coding=utf-8 import asyncio import functools import l...
Python非常详细编程笔记.zip_python 详细笔记_python编程
09-19
这份“Python非常详细编程笔记”涵盖了Python的基础到进阶知识，是学习Python编程的理想资源。以下将详细介绍其中可能涵盖的一些核心知识点： 1. **Python基础知识**：这包括Python的安装、环境配置以及开发工具的...
python 异步io 写excel_python异步IO编程(二)
weixin_39637723的博客
12-21 533
python异步IO编程(二)目录开门见山Async IO设计模式事件循环asyncio中的其他顶层函数开门见山下面我们用两个简单的例子来让你对异步IO有所了解importasyncioasyncdefcount():print("One")await asyncio.sleep(1)print("Two")asyncdefmain():await asyncio.gather(count(),...
学习笔记(13):Python网络编程&并发编程-解决粘包问题-终极版本
12-22
并发编程在Python中可以通过多线程、多进程或异步IO等方式实现。在这个场景下，如果同时有多个客户端请求，可以考虑使用线程池或者异步IO模型（如`asyncio`库）来处理并发连接，提高服务器的响应效率。 总结来说，...
python+django学习笔记
最新发布
02-05
在"python-month3-master"这个文件夹中，可能包含了作者在第三个月学习Python和Django过程中积累的笔记和项目。这可能包括了对Python高级特性的探讨，如装饰器、生成器、上下文管理器，以及Django中的复杂应用场景，...
pythonawait教程_在python里使用await关键字来等另外一个协程的实例
weixin_39789646的博客
02-20 213
一个协程里可以启动另外一个协程，并等待它完成返回结果，采用await关键字，例子如下：import asyncioasync def outer():print('in outer')print('waiting for result1')result1 = await phase1()print('waiting for result2')result2 = await phase2(resul...
python3-asyncio 学习笔记 3 -- run_until_complete
weixin_34128534的博客
03-24 8442
2019独角兽企业重金招聘Python工程师标准>>> ...
关于 Asyncio，别再使用run_until_complete了
希夜希希希的博客
07-03 3180
Python asyncio.run() 源码解读
多任务编程事件循环
发呆的比目鱼的博客
01-09 988
多任务编程事件循环 事件循环 事件循环，可以把他当做是一个while循环，这个while循环在周期性的运行并执行一些任务，在特定条件下终止循环。 # 伪代码 任务列表 = [ 任务1, 任务2, 任务3,... ] while True: 可执行的任务列表，已完成的任务列表 = 去任务列表中检查所有的任务，将'可执行'和'已完成'的任务返回 for 就绪任务 in 已准备就绪的任务列表: 执行已就绪的任务 for 已完成的任务 in 已完成的任务列表:
前端（4）JavaScript
shitou987的博客
09-17 275
待补充
python 异步 async/await（进阶详解）
热门推荐
qq_43380180的博客
12-23 6万+
CPU的时间观 I/O（异步的瓶颈） 基础概念 进程/线程 阻塞/非阻塞 并发/并行 CPU调度策略 同步/异步 事件循环+回调 协程（异步） async/await asyncio事件循环（python3.6） asyncio事件循环（python3.7） async await asyncio.create_task() asyncio.futures对象 实例 参考
python爬虫进阶篇（异步）
screamn的博客
11-25 1449
异步学习完前面的基础知识后，我们会发现这些爬虫的效率实在是太低了。那么我们需要学习一些新的爬虫方式来进行信息的获取。异步使用python3.7后的版本中的异步进行爬取，多线程虽然快，但是异步才是爬虫真爱。基本概念讲解1.什么是异步？异步是指在程序执行过程中，当遇到耗时的操作时，不会等待这个操作完成才继续执行后面的代码，而是先去执行其他的操作，等到耗时的操作完成后再处理它的结果。这种方式能够提高程序的并发性和响应性。
python loop until_python3-asyncio 学习笔记 3 -- run_until_complete
weixin_39856589的博客
12-05 1605
在笔记1中追踪了call_soon这中调用方式是如何运行的,这次看一看run_until_complete是怎么工作的.还是由一个简单的例子开始:import asyncioasync def hi(loop):print("Hello World")loop = asyncio.get_event_loop()# Blocking call which returns when the di...
python 协程库 asyncio 使用
白发渔礁江渚上……
06-16 3054
asyncio提供的框架以事件循环(event loop)为中心，程序开启一个无限的循环，程序会把一些函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。 事件循环loop调用方法loop.run_until_complete(…)驱动传入的参数，它的参数是一个future或者协程。如果是协程，run_until_complete方法和wait函数一样，把协程包装进一个Task对象中。...
Python编程语言学习笔记（中文版）
Python 学习笔记（中文版） Python 是一种高级、解释型的编程语言，广泛应用于数据科学、人工智能、Web 开发等领域。本文档提供了 Python 的基础知识点，包括数据类型、控制结构、函数、模块、异常处理等。 §1.1 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值