欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python之协程学习

程序员文章站 2022-03-27 10:31:02
协程协程介绍yield实现协程及扩展yield from的使用替代产出值的嵌套for循环yield from打开双向通道greenlet实现协程greenlet安装greenlet实现gevent实现协程gevent介绍gevent安装gevent使用异步编程同步与异步async/await实现协程async实现await实现Tasks实现简单总结协程介绍协程,又称为微线程,它是实现多任务的另一种方式,只不过它是一种比线程更加轻量级的存在。因为它自带CPU的上下文,这样只要在合适的时机,我们就可以把一个...

协程介绍

协程,又称为微线程,它是实现多任务的另一种方式,只不过它是一种比线程更加轻量级的存在。因为它自带CPU的上下文,这样只要在合适的时机,我们就可以把一个协程切换到另一个协程。
CPU上下文(CPU寄存器和程序计数器):

  • CPU寄存器是CPU的内置的容量小,但速度极快的内存。
  • 程序计数器则是用来存储CPU正在执行的指令位置、或者即将执行的下一条指令位置。

协程、线程与进程的区别:

  • 协程和线程进程不一样,它只是一个特殊的函数,它们的维度不同
  • 一个进程拥有多个线程,一个线程拥有多个协程
  • 多个协程可以切换,只不过是并发执行的
  • 协程与进程一样,切换是存在上下文切换问题的

yield实现协程及扩展

代码示例

import time


def task1():
    while True:
        print("before --task1-- was wakened!")
        time.sleep(0.5)
        yield
        print("after --task1-- was wakened!")


def task2():
    while True:
        print("before --task2-- was wakened!")
        time.sleep(0.5)
        yield
        print("after --task2-- was wakened!")


def main():
    t1 = task1()
    t2 = task2()
    while True:
        next(t1)
        next(t2)


if __name__ == '__main__':
    main()

运行结果如下:
python之协程学习
生成器拓展

  • 除了能用next()方法唤醒生成器之外,我们还可以用send()方法唤醒,不过使用send()方法必须传参。
  • 如果第一次唤醒生成器用的send(),则必须传参None —> send(None),后面的使用可以传任意参数
  • 如果使用next()作为第一次唤醒,则后面第一次使用的send()可以不用再传None了,而是任意参数
  • 生成器函数return的返回值保存在异常中
  • 如果给yield赋值,例如x = yield,则send(参数)里的参数将会复制给x

这些扩展下面举的双向通道例子会用到

yield from的使用

作用:

  • 1.替代产出值的嵌套for循环
  • 2.yield from的主要功能是打开双向通道,把最外层的调用方与最内层的子生成器连接起来。因为yield from的异常捕获更为完善。

替代产出值的嵌套for循环

需求:

给定一个列表和一个字典:
lis = [1, 2, 3]
dic = {
    "name":"amy",
    "age":18
}
输出结果要求为:
1
2
3
name
age

1、首先我们可以使用itertools模块里的chain()类来实现
chain()类需要传入一个或多个可迭代对象,然后依次通过可迭代对象的__next__()方法返回一个值

  • 代码示例
    from itertools import chain
    
    
    def main():
        lis = [1, 2, 3]
        dic = {
            "name": "amy",
            "age": 18
        }
        for v in chain(lis, dic):
            print(v)
    
    
    if __name__ == '__main__':
        main()
    

2、通过自己封装函数,然后使用yield from实现与chain()类一样的功能

  • 代码示例
    def my_chain(*args):
        for my_iterable in args:
            # for i in my_iterable:
            #     yield i
            # yield from 代替for循环
            yield from my_iterable
    
    
    def main():
        lis = [1, 2, 3]
        dic = {
            "name": "amy",
            "age": 18
        }
        for v in my_chain(lis, dic):
            print(v)
    
    
    if __name__ == '__main__':
        main()
    
    

yield from打开双向通道

首先举个生成器的异常例子
代码示例

def generator_1():
    total = 0
    while True:
        x = yield
        print('总和加', x)
        # 如果传的x是None,则会跳出循环
        if not x:
            break
        total += x
    return '发生异常,总和为%d' % total


def main():
    g = generator_1()
    g.send(None)
    g.send(2)
    g.send(3)
    g.send(None)


if __name__ == '__main__':
    main()

运行结果:
python之协程学习
发生异常则会显示生成器的返回值,如果我们想将生成器的返回值存在一个变量中,而不是在异常里,这时我们可以使用yield from做一个委派生成器来实现
代码示例

def generator_1():
    total = 0
    while True:
        x = yield
        print('总和加', x)
        # 如果传的x是None,则会跳出循环
        if not x:
            break
        total += x
    return total


def generator_2():
    while True:
        total = yield from generator_1()
        print('总数为', total)


def main():
    g = generator_2()
    g.send(None)
    g.send(2)
    g.send(3)
    g.send(None)


if __name__ == '__main__':
    main()

运行结果:
python之协程学习
这时generator_1()生成器发生的异常会赋值给generator_2()total并且打印出来

greenlet实现协程

greenlet安装

pip install greenlet

greenlet实现

当创建一个greenlet时,首先初始化一个空的栈, switch到这个栈的时候,会运行在greenlet构造时传入的函数
代码示例

import time
from greenlet import greenlet


def task1():
    while True:
        print('task1')
        # 切换协程
        gl2.switch()
        time.sleep(1)
        print('从其他协程切换到task1')


def task2():
    while True:
        print('task2')
        # 切换协程
        gl1.switch()
        time.sleep(1)
        print('从其他协程切换到task2')


if __name__ == '__main__':
    gl1 = greenlet(task1)
    gl2 = greenlet(task2)
    # 启动协程
    gl1.switch()

运行结果:
python之协程学习

gevent实现协程

gevent介绍

greenlet已经实现了协程,但是这个还的人工切换,就很麻烦,python还有一个比greenlet更强大的并且能够自动切换任务的模块 gevent
原理:

  • 当一个greenlet遇到IO操作时,比如访问网络/睡眠等待,就自动切换到其他的greenlet,等到IO操作完成,再在适当的时候切换回来继续执行
  • 由于IO操作非常耗时,经常使程序处于等待状态,有了gevent为我们自动切换协程,就保证总有greenlet在运行,而不是等待IO

gevent安装

pip install gevent

gevent使用

代码示例

import gevent


def task1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep(1)
        print('task1 >', i, '结束')


def task2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep(1)
        print('task2 >', i, '结束')


if __name__ == '__main__':
    g1 = gevent.spawn(task1, 5)
    g2 = gevent.spawn(task2, 5)

    g1.join()
    g2.join()

gevent利用协程延时的时候切换到其他协程,但是只针对与gevent.sleep(),如果使用gevent中的monkey.patch_all(),可以将所有的延时都转换成gevent.sleep(),然后一个一个创建g1,g2,最后还要调用join()方法,代码量过大,可以使用gevent.joinall包装起来
代码示例

from gevent import monkey
import gevent
monkey.patch_all()
import requests


def download(url):
    print(f'get - > {url}')
    data = requests.get(url).text
    print(len(data), url)


if __name__ == '__main__':
    # 参数为可迭代对象
    gevent.joinall(
        [
            gevent.spawn(download, 'https://www.baidu.com/'),
            gevent.spawn(download, 'https://www.baidu.com/'),
            gevent.spawn(download, 'https://www.python.org/')
        ]
    )

注意 monkey.patch_all()语句要放在import requests语句上面

异步编程

同步与异步

同步: 是指代码调用IO操作时,必须等待IO操作完成才返回的调用方式,多个任务之间执行的时候要求有先后顺序,必须一个先执行完成之后,另一个才能继续执行, 只有一个主线
异步: 是指代码调用IO操作时,不必等IO操作完成就返回的调用方式,多个任务之间执行没有先后顺序,可以同时运行,执行的先后顺序不会有什么影响,存在的多条运行主线

async/await实现协程

Python中使用协程最常用的库就是asyncio

  • async/await 关键字:python3.5用于定义协程的关键字,async定义一个协程,await用于挂起阻塞的异步调用接口。
  • coroutine 协程:协程对象,只一个使用async关键字定义的函数,他的调用不会立即执行函数,而是会返回一个协程对象。协程对象需要注册到事件循环中,由事件循环调用。
  • event_loop 事件循环:相当于一个无限循环,我们可以把一些函数注册到这个事件循环上,当满足条件时,就会调用对应的处理方法。
  • task 任务:一个协程对象就是一个原生可以挂起的函数,任务则是对协程的进一步封装,其中包含任务的各种状态。
  • future:代表将来执行或没有执行的任务结果。它与task没有本质的区别。

async实现

协程函数:定义函数的时候加上async,例如async def 函数名
代码示例

import asyncio


async def a():
    print('a')


if __name__ == '__main__':
    result = a()  # 创建一个协程对象,但并不执行
    # loop = asyncio.get_event_loop() # 创建一个事件循环
    # loop.run_until_complete(result) # 加入协程对象并执行
    asyncio.run(result)  # 执行协程

注意:

  • 如果是python3.7以下的版本,则使用下面这两条语句来执行协程
    loop = asyncio.get_event_loop() # 创建一个事件循环
    loop.run_until_complete(result) # 加入协程对象并执行
    
  • 如果是python3.7以上,则可以直接使用下面这条语句来执行协程
    asyncio.run(协程对象)
    

await实现

代码示例

import asyncio


async def a():
    print('一起来玩耍吧!')
    res = await asyncio.sleep(1)    # 等待1秒
    print('结束', res)


if __name__ == '__main__':
    result = a()  # 创建一个协程对象,但并不执行
    asyncio.run(result)  # 执行协程

Tasks实现

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

import asyncio


async def task():
    print('任务开始')
    await asyncio.sleep(1)
    print('任务结束')
    return '返回值'


async def main():
    print('主函数')
    # 创建task对象
    task1 = asyncio.create_task(task())
    task2 = asyncio.create_task(task())

    # 当某协程执行IO操作时,会自动切换到其他协程
    # await等待协程执行完毕并返回结果
    rtn1 = await task1
    rtn2 = await task2

    print(rtn1, rtn2)


if __name__ == '__main__':
    a = main()  # 创建一个协程对象,但并不执行
    asyncio.run(a)  # 执行协程

简单总结

  • 进程是资源分配的单位
  • 线程是操作系统调度的单位
  • 进程切换需要的资源大,效率低
  • 线程切换需要的资源一般,效率一般
  • 协程切换因为是在一个线程里切换,所以效率高
  • 多进程、多线程的执行,如果cpu的核数多,那么是并行的,但是协程是在一个线程里执行,所以是并发的

最后,有喜欢博主写的内容的伙伴可以点赞收藏加关注哦!

本文地址:https://blog.csdn.net/weixin_44604586/article/details/107226134