python协程理解

麦兜顶当当

已于 2024-08-07 16:41:27 修改

阅读量277

点赞数

文章标签： python

于 2022-02-15 23:05:28 首次发布

本文链接：https://blog.youkuaiyun.com/qq_39089855/article/details/122952852

版权

本文介绍了Python中的生成器和异步编程的概念，通过示例展示了如何使用生成器实现迭代操作，以及如何利用async/await进行任务调度。在生成器示例中，详细解释了如何在B中激活A生成器并进行值传递。接着，通过asyncio库的worker_1和worker_2异步函数展示了并发执行的任务调度过程。最后，用生产者消费者模型演示了如何利用异步队列实现任务分配与消费。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义一个A生成器,B中调用send(None)激活A，yield值1即from_a

B进入循环，send(to_a)即第一次传'x'值给a，a中from_b接收到b的值，执行到yield to_b传入值2给from_a

'1'->x->'2'->y->'3'->'z'->抛出StopIteration

import time
def A():
    a_list=['1','2','3']
    for to_b in a_list:
        print('a %f' % time.time())
        from_b=yield to_b
        print('receive %s from B'%from_b)
        print('do some complex process for a during 200ms')


def B(a):
    from_a=a.send(None)
    print('response %s from A'%from_a)
    print('B is analysising data from A')
    b_list=['x','y','z']

    try:
        # print('staert')
        for to_a in b_list:
            print('B %f' % time.time())
            from_a=a.send(to_a)
            print('response %s from A'%from_a)
            print('B is analysising data from A')
    except StopIteration:
        print('---from a done---')
    finally:
        a.close()

a=A()
# for i in a:
#    print(i)
B(a)

迭代生成器：

通过for循环，yield关键字返回结果，不会占用内存

def accumulate_div(a):
    total=1
    for i in a:
        total *=i
        yield total

a=[1,2,3,4,5]

for i in accumulate_div(a):
    print(i)

# print(list(accumulate_div(a)))

async await新协程，定义两个异步函数worker_1,worker_2，创建task，await task1时，执行worker_1，worker_1执行到asyncio.sleep(1)，调度器切出去，开始worker_2，worker_2执行到await asyncio.slee(2)切出去，等待worker_1 sleep结束，执行worker_1 done然后awaited worker_1,等待worker_2 sleep结束，执行worker_2 done,awaited_worker_2：

import asyncio

async def worker_1():
    print('worker_1 start')
    await asyncio.sleep(1)
    print('worker_1 done')

async def worker_2():
    print('worker_2 start')
    await asyncio.sleep(2)
    print('worker_2 done')

async def main():
    task1=asyncio.create_task(worker_1())
    task2=asyncio.create_task(worker_2())
    print('before await')
    await task1
    print('awaited worker_1')
    await task2
    print('awaited_worker_2')

asyncio.run(main())

执行结果：
before await
worker_1 start
worker_2 start
worker_1 done
awaited worker_1
worker_2 done
awaited_worker_2

生产者消费者

import asyncio
import random


async def consumer(queue, id):
    while True:
        val = await queue.get()
        print('{} get a val: {}'.format(id, val))
        await asyncio.sleep(1)


async def producer(queue, id):
    for i in range(5):
        val = random.randint(1, 10)
        await queue.put(val)
        print('{} put a val: {}'.format(id, val))
        await asyncio.sleep(1)


async def main():
    queue = asyncio.Queue()

    consumer_1 = asyncio.create_task(consumer(queue, 'consumer_1'))
    consumer_2 = asyncio.create_task(consumer(queue, 'consumer_2'))

    producer_1 = asyncio.create_task(producer(queue, 'producer_1'))
    producer_2 = asyncio.create_task(producer(queue, 'producer_2'))

    await asyncio.sleep(10)
    consumer_1.cancel()
    consumer_2.cancel()

    await asyncio.gather(consumer_1, consumer_2, producer_1, producer_2, return_exceptions=True)

asyncio.run(main())