网站建设佰金手指科杰十三,如何创建个人网站免费,信息流广告代理商的盈利模式,广州网络推广外包一、协程的认识
协程#xff08;Coroutine#xff09;#xff0c;也可以被称为微线程#xff0c;是一种用户态内的上下文切换技术。
简而言之#xff0c;其实就是通过一个线程实现代码块相互切换执行。例如#xff1a;deffunc1():print(1)
...print(2)deffunc2():print(3…一、协程的认识
协程Coroutine也可以被称为微线程是一种用户态内的上下文切换技术。
简而言之其实就是通过一个线程实现代码块相互切换执行。例如deffunc1():print(1)
...print(2)deffunc2():print(3)
...print(4)
func1()
func2()
上面代码可以看出来是串行的如果有一个函数阻塞则其它函要等待导致时间浪费这个就是协程存在的原因。
二、操作协程的模块有哪些呢
在Python中有多种方式可以实现协程例如
1、greenlet是一个第三方模块用于实现协程代码Gevent协程就是基于greenlet实现2、yield生成器借助生成器的特点也可以实现协程代码。
3、asyncio在Python3.4中引入的模块用于编写协程代码。
4、async awiat在Python3.5中引入的两个关键字结合asyncio模块可以更方便的编写协程代码。
1、greenlet示例from greenlet importgreenletdeffunc1():print(1) #第1步输出 1
gr2.switch() #第3步切换到 func2 函数
print(2) #第6步输出 2
gr2.switch() #第7步切换到 func2 函数从上一次执行的位置继续向后执行
deffunc2():print(3) #第4步输出 3
gr1.switch() #第5步切换到 func1 函数从上一次执行的位置继续向后执行
print(4) #第8步输出 4
if __name__ __main__:
gr1greenlet(func1)
gr2greenlet(func2)
gr1.switch()#第1步去执行 func1 函数
#输出结果
#1
#3
#2
#4
注意switch中也可以传递参数用于在切换执行时相互传递值。
greenlet示例
2、yield示例deffunc1():yield 1
yield fromfunc2()yield 2
deffunc2():yield 3
yield 4
if __name__ __main__:
f1func1()for item inf1:print(item)#输出结果
#1
#3
#4
#2
注意yield form关键字是在Python3.3中引入的
yield示例
3、asyncio示例importasyncio
asyncio.coroutinedeffunc1():print(1)yield from asyncio.sleep(2) #遇到IO耗时操作自动化切换到tasks中的其他任务
print(2)
asyncio.coroutinedeffunc2():print(3)yield from asyncio.sleep(2) #遇到IO耗时操作自动化切换到tasks中的其他任务
print(4)if __name__ __main__:
tasks[
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2())
]
loopasyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
注意
基于asyncio模块实现的协程比之前的要更厉害因为他的内部还集成了遇到IO耗时操作自动切花的功能。
在Python3.4之前官方未提供协程的类库一般大家都是使用greenlet等其他来实现。在Python3.4发布后官方正式支持协程即asyncio模块。
asyncio示例
4、async await示例importasyncio
asyncdeffunc1():print(1)
await asyncio.sleep(2)print(2)
asyncdeffunc2():print(3)
await asyncio.sleep(2)print(4)if __name__ __main__:
tasks[
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2())
]
loopasyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))#输出结果
#1
#3
#2
#4
注意
asyncawit 关键字在Python3.5版本中正式引入基于他编写的协程代码其实就是 上一示例 的加强版让代码可以更加简便。
Python3.8之后 asyncio.coroutine 装饰器就会被移除推荐使用async awit 关键字实现协程代码。
async await示例
5、小结
关于协程有多种实现方式目前主流使用是Python官方推荐的asyncio模块和asyncawait关键字的方式
例如在tonado、sanic、fastapi、django3 中均已支持。
三、协程的意义
通过学习我们已经了解到协程可以通过一个线程在多个上下文中进行来回切换执行。
但是协程来回切换执行的意义何在呢
1、计算型的操作利用协程来回切换执行没有任何意义来回切换并保存状态 反倒会降低性能。
2、IO型的操作利用协程在IO等待时间就去切换执行其他任务当IO操作结束后再自动回调那么就会大大节省资源并提供性能
从而实现异步编程不等待任务结束就可以去执行其他代码。
1、爬虫案例
1.1、同步爬虫案例importrequestsdefdownload_image(url):print(开始下载:, url)#发送网络请求下载图片
response requests.get(url)print(下载完成)#图片保存到本地文件
file_name url.rsplit(_)[-1]
with open(file_name, modewb) as file_object:
file_object.write(response.content)if __name__ __main__:url_list[https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg,https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg,https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg]for item inurl_list:
download_image(item)
注意请提前安装pip3 install requests
同步爬虫案例
1.2、异步爬虫案例importaiohttpimportasyncio
asyncdeffetch(session, url):print(发送请求, url)
async with session.get(url, verify_sslFalse) as response:
contentawait response.content.read()
file_name url.rsplit(_)[-1]
with open(file_name, modewb) as file_object:
file_object.write(content)
asyncdefmain():
async with aiohttp.ClientSession() as session:url_list[https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg,https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg,https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg]
tasks [asyncio.create_task(fetch(session, url)) for url inurl_list]
await asyncio.wait(tasks)if __name__ __main__:
asyncio.run(main())
注意请提前安装pip3 install aiohttp
异步爬虫案例
1.3、同步编程和异常编程的对比
上述两种的执行对比之后会发现基于协程的异步编程 要比 同步编程的效率高了很多。因为
同步编程按照顺序逐一排队执行如果图片下载时间为2分钟那么全部执行完则需要6分钟。
异步编程几乎同时发出了3个下载任务的请求遇到IO请求自动切换去发送其他任务请求如果图片下载时间为2分钟那么全部执行完毕也大概需要2分钟左右就可以了。
1.4、总结
协程一般应用在有IO操作的程序中因为协程可以利用IO等待的时间去执行一些其他的代码从而提升代码执行效率。
生活中不也是这样的么假设 你是一家制造汽车的老板员工点击设备的【开始】按钮之后在设备前需等待30分钟
然后点击【结束】按钮此时作为老板的你一定希望这个员工在等待的那30分钟的时间去做点其他的工作。
四、异步编程
基于async await关键字的协程可以实现异步编程这也是目前python异步相关的主流技术。
想要真正的了解Python中内置的异步编程根据下文的顺序一点点来看。
1、事件循环的概述
事件循环可以把他当做是一个while循环这个while循环在周期性的运行并执行一些任务在特定条件下终止循环。在编写程序时候可以通过如下代码来获取和创建事件循环。importasyncio
loop asyncio.get_event_loop()#伪代码
任务列表 [ 任务1, 任务2, 任务3,... ]whileTrue:
可执行的任务列表已完成的任务列表 去任务列表中检查所有的任务将可执行和已完成的任务返回for 就绪任务 in已准备就绪的任务列表:
执行已就绪的任务for 已完成的任务 in已完成的任务列表:
在任务列表中移除 已完成的任务
如果 任务列表 中的任务都已完成则终止循环
伪代码
2、基本应用的示例
程序中如果想要执行协程函数的内部代码需要 事件循环 和 协程对象 配合才能实现如
2.1、方式一、手动创建事件循环importasyncio
asyncdeffunc():print(协程内部代码)if __name__ __main__:#调用协程函数返回一个协程对象。
result func()
loop asyncio.get_event_loop() #创建一个事件循环
loop.run_until_complete(result) #将协程当做任务提交到事件循环的任务列表中协程执行完成之后终止。
get_event_loop获取事件循环
2.2、方式二、async.run创建 事件循环importasyncio
asyncdeffunc():print(协程内部代码)if __name__ __main__:#调用协程函数返回一个协程对象。
result func()#本质上方式一是一样的内部先 创建事件循环 然后执行 run_until_complete一个简便的写法。
#asyncio.run 函数在 Python 3.7 中加入 asyncio 模块
asyncio.run(result)
async.run创建 事件循环
3、await
await是一个只能在协程函数中使用的关键字用于遇到IO操作时挂起 当前协程任务当前协程任务挂起过程中 事件循环可以去执行其他的协程任务
当前协程IO处理完成时可以再次切换回来执行await之后的代码。代码如下
3.1、示例1、单任务等待IO再运行importasyncio
asyncdeffunc():print(执行协程函数内部代码)#遇到IO操作挂起当前协程任务等IO操作完成之后再继续往下执行。
#当前协程挂起时事件循环可以去执行其他协程任务。
response await asyncio.sleep(2)print(IO请求结束结果为, response)
resultfunc()
asyncio.run(result)
示例1
3.2、示例2、遇到IO阻塞切至其它任务运行importasyncio
asyncdefothers():print(start)
await asyncio.sleep(2)print(end)return 返回值asyncdeffunc():print(执行协程函数内部代码)#遇到IO操作挂起当前协程任务等IO操作完成之后再继续往下执行。当前协程挂起时事件循环可以去执行其他协程任务。
response await others()print(IO请求结束结果为, response)
asyncio.run(func())
示例2
3.3、示例3、同一个协程函数可以调用多个协程函数importasyncio
asyncdefothers():print(start)
await asyncio.sleep(2)print(end)return 返回值asyncdeffunc():print(执行协程函数内部代码)#遇到IO操作挂起当前协程任务等IO操作完成之后再继续往下执行。当前协程挂起时事件循环可以去执行其他协程任务。
response1 await others()print(IO请求结束结果为, response1)
response2await others()print(IO请求结束结果为, response2)
asyncio.run(func())
示例3
3.4、总结
上述的所有示例都只是创建了一个任务即事件循环的任务列表中只有一个任务所以在IO等待时无法演示切换到其他任务效果。
在程序想要创建多个任务对象需要使用Task对象来实现。
4、Task对象
官方文档
Tasks are used to schedule coroutines concurrently.
When a coroutineis wrapped into a Task with functions like asyncio.create_task() the coroutine isautomatically scheduled to run soon。
翻译
Tasks用于并发调度协程通过asyncio.create_task(协程对象)的方式创建Task对象这样可以让协程加入事件循环中等待被调度执行。
除了使用 asyncio.create_task() 函数以外还可以用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
本质上是将协程对象封装成task对象并将协程立即加入事件循环同时追踪协程的状态。
注意asyncio.create_task() 函数在 Python3.7 中被加入。在 Python 3.7 之前可以改用低层级的 asyncio.ensure_future() 函数。
4.1、示例1、单个task单个task创建的示例importasyncio
asyncdeffunc():print(1)
await asyncio.sleep(2)print(2)return 返回值asyncdefmain():print(main开始)#创建协程将协程封装到一个Task对象中并立即添加到事件循环的任务列表中等待事件循环去执行默认是就绪状态。
task1 asyncio.create_task(func())#创建协程将协程封装到一个Task对象中并立即添加到事件循环的任务列表中等待事件循环去执行默认是就绪状态。
task2 asyncio.create_task(func())print(main结束)#当执行某协程遇到IO操作时会自动化切换执行其他任务。
#此处的await是等待相对应的协程全都执行完毕并获取结果
ret1 await task1
ret2await task2print(ret1, ret2)
asyncio.run(main())
示例1
4.2、示例2、将多个create_task任务放在列表中执行importasyncio
asyncdeffunc():print(1)
await asyncio.sleep(2)print(2)return 返回值asyncdefmain():print(main开始)#创建协程将协程封装到Task对象中并添加到事件循环的任务列表中等待事件循环去执行默认是就绪状态。
#在调用
task_list [
asyncio.create_task(func()),
asyncio.create_task(func())
]print(main结束)#当执行某协程遇到IO操作时会自动化切换执行其他任务。
#此处的await是等待所有协程执行完毕并将所有协程的返回值保存到done
#如果设置了timeout值则意味着此处最多等待的秒完成的协程返回值写入到done中未完成则写到pending中。
done, pending await asyncio.wait(task_list, timeoutNone)print(done, pending)
asyncio.run(main())
示例2
注意asyncio.wait 源码内部会对列表中的每个协程执行ensure_future从而封装为Task对象所以在和wait配合使用时task_list的值为[func(),func()] 也是可以的
4.3、示例3、将多个任务直接放在列表中执行importasyncio
asyncdeffunc():print(执行协程函数内部代码)#遇到IO操作挂起当前协程任务等IO操作完成之后再继续往下执行。当前协程挂起时事件循环可以去执行其他协程任务。
response await asyncio.sleep(2)print(IO请求结束结果为, response)
coroutine_list[func(), func()]#错误coroutine_list [ asyncio.create_task(func()), asyncio.create_task(func()) ]#此处不能直接 asyncio.create_task因为将Task立即加入到事件循环的任务列表#但此时事件循环还未创建所以会报错。#使用asyncio.wait将列表封装为一个协程并调用asyncio.run实现执行两个协程#asyncio.wait内部会对列表中的每个协程执行ensure_future封装为Task对象。
done, pending asyncio.run(asyncio.wait(coroutine_list))
示例3
5、asyncio.Future对象
官文描述
A Futureis a special low-level awaitable object that represents an eventual result of an asynchronous operation.
翻译
asyncio中的Future对象是一个相对更偏向底层的可对象通常我们不会直接用到这个对象而是直接使用Task对象来完成任务的并和状态的追踪。 Task 是 Futrue的子类
Future为我们提供了异步编程中的 最终结果 的处理Task类也具备状态处理的功能。
5.1、示例1、不跑任何任务运行Futureimportasyncio
asyncdefmain():#获取当前事件循环
loop asyncio.get_running_loop()## 创建一个任务Future对象这个任务什么都不干。
fut loop.create_future()#等待任务最终结果Future对象没有结果则会一直等下去。
await fut
asyncio.run(main())
示例1
5.2、示例2、 给Future设置任务运行importasyncio
asyncdefset_after(fut):
await asyncio.sleep(2)
fut.set_result(666)
asyncdefmain():#获取当前事件循环
loop asyncio.get_running_loop()#创建一个任务Future对象没绑定任何行为则这个任务永远不知道什么时候结束。
fut loop.create_future()#创建一个任务Task对象绑定了set_after函数函数内部在2s之后会给fut赋值。
#即手动设置future任务的最终结果那么fut就可以结束了。
await loop.create_task(set_after(fut))#等待 Future对象获取 最终结果否则一直等下去
data await futprint(data)
asyncio.run(main())
示例2
5.3、总结
Future对象本身函数进行绑定所以想要让事件循环获取Future的结果则需要手动设置。而Task对象继承了Future对象
其实就对Future进行扩展他可以实现在对应绑定的函数执行完成之后自动执行set_result从而实现自动结束。
虽然平时使用的是Task对象但对于结果的处理本质是基于Future对象来实现的。
扩展支持 await 对象语 法的对象课成为可等待对象所以 协程对象、Task对象、Future对象 都可以被成为可等待对象。
6、futures.Future对象
在Python的concurrent.futures模块中也有一个Future对象这个对象是基于线程池和进程池实现异步操作时使用的对象。importtimefrom concurrent.futures importFuturefrom concurrent.futures.thread importThreadPoolExecutorfrom concurrent.futures.process importProcessPoolExecutordeffunc(value):
time.sleep(1)print(value)
pool ThreadPoolExecutor(max_workers5)#或 pool ProcessPoolExecutor(max_workers5)
for i in range(10):
futpool.submit(func, i)print(fut)运行结果:0
2
1
4
3
7
6
9
8
5
Future对象的示例
两个Future对象是不同的他们是为不同的应用场景而设计例如concurrent.futures.Future不支持await语法 等。
官方提示两对象之间不同
unlike asyncio Futures, concurrent.futures.Future instances cannot be awaited.
asyncio.Future.result()and asyncio.Future.exception() do notaccept the timeout argument.
asyncio.Future.result()and asyncio.Future.exception() raise an InvalidStateError exception when the Future is notdone.
Callbacks registered with asyncio.Future.add_done_callback() arenotcalled immediately. They are scheduled with loop.call_soon() instead.
asyncio Futureis not compatible with the concurrent.futures.wait() andconcurrent.futures.as_completed() functions.
在Python提供了一个将futures.Future 对象包装成asyncio.Future对象的函数 asynic.wrap_future。
一般在程序开发中我们要么统一使用 asycio 的协程实现异步操作、要么都使用进程池和线程池实现异步操作。
但如果协程的异步和进程池/线程池的异步混搭时那么就会用到此功能了。
6.1、利用asyncio/futures.ThreadPoolExecutor/futures.ProcessPoolExecutor 将非协程函数转为Future对象再给事件循环异步importtimeimportasyncioimportconcurrent.futuresdeffunc1():#某个耗时操作
time.sleep(2)return SBasyncdefmain():
loopasyncio.get_running_loop()#1. Run in the default loops executor ( 默认ThreadPoolExecutor )
#第一步内部会先调用 ThreadPoolExecutor 的 submit 方法去线程池中申请一个线程去执行func1函数并返回一个concurrent.futures.Future对象
#第二步调用asyncio.wrap_future将concurrent.futures.Future对象包装为asycio.Future对象。
#因为concurrent.futures.Future对象不支持await语法所以需要包装为 asycio.Future对象 才能使用。
fut loop.run_in_executor(None, func1)
resultawait futprint(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())
普通函数转Future对象的三种方法示例
6.2、应用的示例当遇到模块不支持协程时的转换示例importasyncioimportrequests
asyncdefdownload_image(url):#发送网络请求下载图片遇到网络下载图片的IO请求自动化切换到其他任务
print(开始下载:, url)
loopasyncio.get_event_loop()#requests模块默认不支持异步操作所以就使用线程池来配合实现了。
future loop.run_in_executor(None, requests.get, url)
responseawait futureprint(下载完成)#图片保存到本地文件
file_name url.rsplit(_)[-1]
with open(file_name, modewb) as file_object:
file_object.write(response.content)if __name__ __main__:url_list[https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg,https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg,https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg]
tasks [download_image(url) for url inurl_list]
loopasyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
requests模块转为异步的运行示例
7、异步迭代器
7.1、什么是异步迭代器
实现了 __aiter__() 和 __anext__() 方法的对象。__anext__ 必须返回一个 awaitable 对象。async for 会处理异步迭代器的 __anext__() 方法所返回的可等待对象
直到其引发一个 StopAsyncIteration 异常。由 PEP 492 引入。
7.2、什么是异步可迭代对象
可在 async for 语句中被使用的对象。必须通过它的 __aiter__() 方法返回一个
asynchronous iterator。由 PEP 492 引入。importasyncioclassReader(object):自定义异步迭代器同时也是异步可迭代对象
def __init__(self):
self.count0
asyncdefreadline(self):#await asyncio.sleep(1)
self.count 1
if self.count 100:returnNonereturnself.countdef __aiter__(self):returnself
asyncdef __anext__(self):
valawait self.readline()if val None:raiseStopAsyncIterationreturnval
asyncdeffunc():#创建异步可迭代对象
async_iter Reader()#async for 必须要放在async def函数内否则语法错误。
async for item inasync_iter:print(item)
asyncio.run(func())
注意异步迭代器其实没什么太大的作用只是支持了async for语法而已。
异步迭代器的示例
7.3、异步上下文管理器
此种对象通过定义 __aenter__() 和 __aexit__() 方法来对 async with 语句中的环境进行控制。由 PEP 492 引入。importasyncioclassAsyncContextManager:def __init__(self, conn):
self.connconn
asyncdefdo_something(self):#异步操作数据库
return 666asyncdef __aenter__(self):#异步链接数据库
self.conn await asyncio.sleep(1)returnself
asyncdef __aexit__(self, exc_type, exc, tb):#异步关闭数据库链接
await asyncio.sleep(1)
asyncdeffunc():
connNone
async with AsyncContextManager(conn) as f:
resultawait f.do_something()print(result)
asyncio.run(func())
异步上下文管理器的示例
注意这个异步的上下文管理器还是比较有用的平时在开发过程中 打开、处理、关闭 操作时就可以用这种方式来处理。
7.4、总结
在程序中只要看到async和await关键字其内部就是基于协程实现的异步编程这种异步编程是通过一个线程在IO等待时间去执行其他任务从而实现并发。
8、uvloop
Python标准库中提供了asyncio模块用于支持基于协程的异步编程。
uvloop是 asyncio 中的事件循环的替代方案替换后可以使得asyncio性能提高。
事实上uvloop要比nodejs、gevent等其他python异步框架至少要快2倍性能可以比肩Go语言。
8.1、安装uvloop
pip3 install uvloop
项目中想要使用uvloop替换asyncio的事件循环也非常简单只要在代码中这么做就行importasyncioimportuvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())#编写asyncio的代码与之前写的代码一致。#内部的事件循环自动化会变为uvloop
asyncio.run(...)
注意知名的asgi uvicorn内部就是使用的uvloop的事件循环。
uvloop的使用示例
五、实战
为了更好理解下面所有示例的IO情况都是以 asyncio.sleep 为例而真实的项目开发中会用到很多IO的情况。
1、异步Redis
当通过python去操作redis时链接、设置值、获取值 这些都涉及网络IO请求使用asycio异步的方式可以在IO等待时去做一些其他任务从而提升性能。
安装Python异步操作redis模块
pip3 install aioredis
1.1、示例1异步操作redis#!/usr/bin/env python#-*- coding:utf-8 -*-
importasyncioimportaioredis
asyncdefexecute(address, password):print(开始执行, address)#网络IO操作创建redis连接
redis await aioredis.create_redis(address, passwordpassword, db3)#网络IO操作在redis中设置哈希值car内部在设三个键值对即 redis { car:{key1:1,key2:2,key3:3}}
await redis.hmset_dict(car, key11, key22, key33)#网络IO操作去redis中获取值
result await redis.hgetall(car, encodingutf-8)print(result)
redis.close()#网络IO操作关闭redis连接
await redis.wait_closed()print(结束, address)
asyncio.run(execute(redis://192.168.2.129:6379, redis))
异步操作redis的示例
1.2、示例2连接多个redis做操作遇到IO会切换其他任务提供了性能#!/usr/bin/env python#-*- coding:utf-8 -*-
importasyncioimportaioredis
asyncdefexecute(address, password):print(开始执行, address)#网络IO操作先去连接 47.93.4.197:6379遇到IO则自动切换任务去连接47.93.4.198:6379
redis await aioredis.create_redis_pool(address, passwordpassword)#网络IO操作遇到IO会自动切换任务
await redis.hmset_dict(car, key11, key22, key33)#网络IO操作遇到IO会自动切换任务
result await redis.hgetall(car, encodingutf-8)print(result)
redis.close()#网络IO操作遇到IO会自动切换任务
await redis.wait_closed()print(结束, address)
task_list[
execute(redis://47.93.4.197:6379, root!2345),
execute(redis://47.93.4.198:6379, root!2345)
]
asyncio.run(asyncio.wait(task_list))
异步多链接操作redis示例
2、异步MySQL
当通过python去操作MySQL时连接、执行SQL、关闭都涉及网络IO请求使用asycio异步的方式可以在IO等待时去做一些其他任务从而提升性能。
安装Python异步操作redis模块
pip3 install aiomysql
2.1、示例1连接数据库发送一条查询语句查询数据#!/usr/bin/env python#-*- coding:utf-8 -*-
importasyncioimportaiomysql
asyncdefexecute():#网络IO操作连接MySQL
conn await aiomysql.connect(host127.0.0.1, port3306, userroot, password123, dbmysql, )#网络IO操作创建CURSOR
cur await conn.cursor()#网络IO操作执行SQL
await cur.execute(SELECT Host,User FROM user)#网络IO操作获取SQL结果
result await cur.fetchall()print(result)#网络IO操作关闭链接
await cur.close()
conn.close()
asyncio.run(execute())
示例一
2.2、示例2多连接数据库 查询数据库#!/usr/bin/env python#-*- coding:utf-8 -*-
importasyncioimportaiomysql
asyncdefexecute(host, password):print(开始, host)#网络IO操作先去连接 47.93.40.197遇到IO则自动切换任务去连接47.93.40.198:6379
conn await aiomysql.connect(hosthost, port3306, userroot, passwordpassword, dbmysql)#网络IO操作遇到IO会自动切换任务
cur await conn.cursor()#网络IO操作遇到IO会自动切换任务
await cur.execute(SELECT Host,User FROM user)#网络IO操作遇到IO会自动切换任务
result await cur.fetchall()print(result)#网络IO操作遇到IO会自动切换任务
await cur.close()
conn.close()print(结束, host)
task_list[
execute(47.93.40.197, root!2345),
execute(47.93.40.197, root!2345)
]
asyncio.run(asyncio.wait(task_list))
示例二
3、FastAPI框架
FastAPI是一款用于构建API的高性能web框架框架基于Python3.6的 type hints搭建。
接下里的异步示例以FastAPI和uvicorn来讲解uvicorn是一个支持异步的asgi。
安装FastAPI web 框架
pip3 install fastapi
安装uvicorn本质上为web提供socket server的支持的asgi一般支持异步称asgi、不支持异步称wsgi
pip3 install uvicorn
3.1、FastAPI aioredis示例#!/usr/bin/env python#-*- coding:utf-8 -*-
importasyncioimportuvicornimportaioredisfrom aioredis importRedisfrom fastapi importFastAPI
appFastAPI()
REDIS_POOL aioredis.ConnectionsPool(redis://47.193.14.198:6379, passwordroot123, minsize1, maxsize10)
app.get(/)defindex():普通操作接口
return {message: Hello World}
app.get(/red)
asyncdefred():异步操作接口
print(请求来了)
await asyncio.sleep(3)#连接池获取一个连接
conn await REDIS_POOL.acquire()
redisRedis(conn)#设置值
await redis.hmset_dict(car, key11, key22, key33)#读取值
result await redis.hgetall(car, encodingutf-8)print(result)#连接归还连接池
REDIS_POOL.release(conn)returnresultif __name__ __main__:
uvicorn.run(luffy:app, host127.0.0.1, port5000, log_levelinfo)
示例
在有多个用户并发请求的情况下异步方式来编写的接口可以在IO等待过程中去处理其他的请求提供性能。
例如同时有两个用户并发来向接口 http://127.0.0.1:5000/red 发送请求服务端只有一个线程同一时刻只有一个请求被处理。
异步处理可以提供并发是因为当视图函数在处理第一个请求时第二个请求此时是等待被处理的状态当第一个请求遇到IO等待时会自动切换去接收并处理第二个请求当遇到IO时自动化切换至其他请求
一旦有请求IO执行完毕则会再次回到指定请求向下继续执行其功能代码。
4、爬虫
在编写爬虫应用时需要通过网络IO去请求目标数据这种情况适合使用异步编程来提升性能接下来我们使用支持异步编程的aiohttp模块来实现。
安装aiohttp模块
pip3 install aiohttp#!/usr/bin/env python#-*- coding:utf-8 -*-
importaiohttpimportasyncio
asyncdeffetch(session, url):print(发送请求, url)
async with session.get(url, verify_sslFalse) as response:
textawait response.text()print(得到结果, url, len(text))
asyncdefmain():
async with aiohttp.ClientSession() as session:
url_list[https://python.org,https://www.baidu.com,https://www.pythonav.com]
tasks [asyncio.create_task(fetch(session, url)) for url inurl_list]
await asyncio.wait(tasks)if __name__ __main__:
asyncio.run(main())
aiohttp爬虫示例
六、总结
为了提升性能越来越多的框架都在向异步编程靠拢例如sanic、tornado、django3.0、django channels组件 等
用更少资源可以做处理更多的事何乐而不为呢。
转载地址https://www.cnblogs.com/wupeiqi/p/12834355.html
