协程,又称为微线程,它是实现多任务的另一种方式,只不过它是一种比线程更加轻量级的存在。因为它自带CPU的上下文,这样只要在合适的时机,我们就可以把一个协程切换到另一个协程。
CPU上下文(CPU寄存器和程序计数器):
协程、线程与进程的区别:
代码示例
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()
运行结果如下:
生成器拓展
next()
方法唤醒生成器之外,我们还可以用send()
方法唤醒,不过使用send()
方法必须传参。send()
,则必须传参None —> send(None)
,后面的使用可以传任意参数next()
作为第一次唤醒,则后面第一次使用的send()
可以不用再传None
了,而是任意参数return
的返回值保存在异常中yield
赋值,例如x = yield
,则send(参数)
里的参数将会复制给x
这些扩展下面举的双向通道例子会用到
作用:
需求:
给定一个列表和一个字典:
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()
首先举个生成器的异常例子
代码示例
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()
运行结果:
发生异常则会显示生成器的返回值,如果我们想将生成器的返回值存在一个变量中,而不是在异常里,这时我们可以使用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()
运行结果:
这时generator_1()
生成器发生的异常会赋值给generator_2()
的total
并且打印出来
pip install 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()
运行结果:
greenlet
已经实现了协程,但是这个还的人工切换,就很麻烦,python还有一个比greenlet
更强大的并且能够自动切换任务的模块 gevent
原理:
greenlet
遇到IO操作时,比如访问网络/睡眠等待,就自动切换到其他的greenlet
,等到IO操作完成,再在适当的时候切换回来继续执行gevent
为我们自动切换协程,就保证总有greenlet
在运行,而不是等待IOpip install 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操作完成就返回的调用方式,多个任务之间执行没有先后顺序,可以同时运行,执行的先后顺序不会有什么影响,存在的多条运行主线
Python中使用协程最常用的库就是asyncio
协程函数:定义函数的时候加上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) # 执行协程
注意:
loop = asyncio.get_event_loop() # 创建一个事件循环
loop.run_until_complete(result) # 加入协程对象并执行
asyncio.run(协程对象)
代码示例
import asyncio
async def a():
print('一起来玩耍吧!')
res = await asyncio.sleep(1) # 等待1秒
print('结束', res)
if __name__ == '__main__':
result = a() # 创建一个协程对象,但并不执行
asyncio.run(result) # 执行协程
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) # 执行协程
最后,有喜欢博主写的内容的伙伴可以点赞收藏加关注哦!
本文地址:https://blog.csdn.net/weixin_44604586/article/details/107226134
如对本文有疑问, 点击进行留言回复!!
自我记录:Python学习之OpenCV 05 图片的颜色提取
python初体验:cmd输入python但是打开microsoft store问题
接口测试框架实战(一) | Requests 与接口请求构造
网友评论