外国有没有中国代做数学作业的网站怎么做免费的网站推广

Python2 时代高性能的网络编程主要是 Twisted、Tornado 和 Gevent 这三个库，但是它们的异步代码相互之间既不兼容也不能移植。Gvanrossum 希望在 Python 3 实现一个原生的基于生成器的协程库，其中直接内置了对异步 IO 的支持，这就是 asyncio，它在 Python 3.4 被引入到标准库。

并发对比

asyncio 使用单线程、单个进程的方式切换（通常程序等待读或写数据时就是切换上下文的时机）。

requests + ThreadPoolExecutor

这里采用的是线程池 + 同步方式，requests 仅支持同步方式：

import timeimport requests
from concurrent.futures import ThreadPoolExecutornumbers = range(12)
url = 'http://httpbin.org/get?a={}'def fetch(a):print(a)r = requests.get(url.format(a))return r.json()['args']['a']start = time.time()# 开三个线程
with ThreadPoolExecutor(max_workers=3) as executor:for num, result in zip(numbers, executor.map(fetch, numbers)):print('fetch({})'.format(num, result))print('使用 requests + ThreadPoolExector 总耗时：{}'.format(time.time() - start))     # 5.696202754974365

asyncio + aiohttp

协程+异步，现在的 asyncio，有了很多的模块已经在支持：aiohttp,aiodns,aioredis 等等 https://github.com/aio-libs：

import asyncio
import time
import aiohttpurl = 'http://httpbin.org/get?a={}'
numbers = range(12)async def fetch(a):async with aiohttp.ClientSession() as session:async with session.get(url.format(a)) as resp:data = await resp.json()	# 等待结果return data['args']['a']start = time.time()
event_loop = asyncio.get_event_loop()	# 新建事件循环
tasks = [fetch(num) for num in numbers]	# 添加到任务列表# asyncio.gather() 按顺序搜集异步任务执行的结果
results = event_loop.run_until_complete(asyncio.gather(*tasks))		# 开启事件循环for num, result in zip(numbers, results):print('fetch({}) = {}'.format(num, result))print('使用 asyncio + aiohttp 总耗时：{}'.format(time.time() - start))     # 1.5458192825317383

在想进行协程切换的地方使用 await 关键字，上述 await r.json() 会等待 I/O切换。可以看到协程+异步的方式比同步+多线程方法整整快了三四倍。

asyncio 的基本使用

协程本质上是异步非阻塞技术，它可以用一组少量的线程来实现多个任务，一旦某个任务阻塞，则可能用同一线程继续运行其他任务，避免大量上下文的切换，Python 中使用 asyncio 标准库实现协程。

关于 asyncio 中的一些关键字：

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

快速入门

import asyncioasync def foo():print('这是一个协程')if __name__ == '__main__':loop = asyncio.get_event_loop()         # 定义 loop 对象，事件循环try:print('开始运行协程')coro = foo()print('进入事件循环')loop.run_until_complete(coro)       # 用协程启动事件循环，协程返回，这个方法停止循环，接受一个 future 对象finally:print('关闭事件循环')loop.close()

运行结果：

开始运行协程
进入事件循环
这是一个协程
关闭事件循环

协程返回值

import asyncioasync def foo():print('这是一个协程')return '返回值'if __name__ == '__main__':loop = asyncio.get_event_loop()try:print('开始运行协程')coro = foo()print('进入事件循环')result = loop.run_until_complete(coro)print('协程返回值：', result)finally:print('关闭事件循环')loop.close()

Tips：run_until_complete 可以获取协程返回值，若没有，则返回 None

协程调用协程

一个协程可以启动另一个协程，从而可以任务根据工作内容，封装到不同的协程中。我们可以在协程中使用await关键字，链式的调度协程，来形成一个协程任务流：

import asyncioasync def foo():print('开始运行协程，主协程')print('等待 result1 协程运行')res1 = await result1()print('等待 result2 协程运行')res2 = await result2('rose')return res1, res2async def result1():print('result1 协程')return 'result1'async def result2(name):print('result2 协程')return 'result2 协程接收了一个参数：', nameif __name__ == '__main__':loop = asyncio.get_event_loop()try:result = loop.run_until_complete(foo())print('返回值：', result)finally:print('关闭事件循环')loop.close()

运行结果：

开始运行协程，主协程
等待 result1 协程运行
result1 协程
等待 result2 协程运行
result2 协程
返回值： ('result1', ('result2 协程接收了一个参数：', 'rose'))
关闭事件循环

协程中调用普通函数

在协程中可以通过一些方法去调用普通的函数。可以使用的关键字有call_soon、call_later、call_at

call_soon

调用立即返回

loop.call_soon(callback, *args, context=None)

大部分的回调函数支持位置参数，而不支持”关键字参数”，如果是想要使用关键字参数，则推荐使用functools.aprtial()对方法进一步包装。可选关键字context允许指定要运行的回调的自定义contextvars.Context。当没有提供上下文时使用当前上下文。在Python 3.7中， asyncio
协程加入了对上下文的支持。使用上下文就可以在一些场景下隐式地传递变量，比如数据库连接session等，而不需要在所有方法调用显示地传递这些变量。

import asyncio
import functoolsdef callback(args, *, kwargs='default'):print('普通函数 callback作为回调函数，获取参数：', args, kwargs)async def main(loop):print('注册 callback')loop.call_soon(callback, 1)loop.call_soon(callback, kwagrs='rose')# wrapped = functools.partial(callback, kwagrs='not default')# loop.call_soon(wrapped, 2)await asyncio.sleep(0.2)if __name__ == '__main__':loop = asyncio.get_event_loop()try:loop.run_until_complete(main(loop))finally:loop.close()

运行结果：

注册 callback
Traceback (most recent call last):
普通函数 callback作为回调函数，获取参数： 1 defaultFile "D:/pycharm resource/Projects/TestDeploy/协程/协程调用普通函数.py", line 21, in <module>loop.run_until_complete(main(loop))File "C:\Python35\Lib\asyncio\base_events.py", line 342, in run_until_completereturn future.result()File "C:\Python35\Lib\asyncio\futures.py", line 274, in resultraise self._exceptionFile "C:\Python35\Lib\asyncio\tasks.py", line 239, in _stepresult = coro.send(value)File "D:/pycharm resource/Projects/TestDeploy/协程/协程调用普通函数.py", line 12, in mainloop.call_soon(callback, kwagrs='rose')
TypeError: call_soon() got an unexpected keyword argument 'kwagrs'

这里用的是 Python3.5，所以 asyncio 没有对上下文的支持

---

call_later

延时调用一个函数

loop.call_later(delay, callback, *args, context=None)		# 事件循环在delay多长时间之后才执行callback函数

import asyncio
from time import ctimedef callback(n):print('普通函数 callback作为回调函数，获取参数：', n)async def main(loop):print('注册 callback')print('起始时间', ctime())loop.call_later(5, callback, 1)print('第一次延迟调用：', ctime())loop.call_later(10, callback, 2)print('第二次延迟调用：', ctime())loop.call_soon(callback, 3)await asyncio.sleep(2)if __name__ == '__main__':loop = asyncio.get_event_loop()try:loop.run_until_complete(main(loop))finally:print('协程结束', ctime())loop.close()

运行结果：

注册 callback
起始时间 Sat Oct 12 10:28:29 2019
第一次延迟调用： Sat Oct 12 10:28:29 2019
第二次延迟调用： Sat Oct 12 10:28:29 2019
普通函数 callback作为回调函数，获取参数： 3
协程结束 Sat Oct 12 10:28:31 2019

总结：

• call_soon会在 call_later 之前执行，和它的位置在哪无关
• call_later的第一个参数越小，越先执行。

---

call_at

loop.call_at(when, callback, *args, context=None)

第一个参数的含义代表的是一个单调时间，它和我们平时说的系统时间有点差异，指的是事件循环内部时间，可以通过loop.time()获取，然后可以在此基础上进行操作。call_later 内部实质是调用 call_at：

import asynciodef call_back(n, loop):print("callback %s  运行时间点 %s" % (n, loop.time()))async def main(loop):now = loop.time()print("当前的内部时间", now)print("循环时间", now)print("注册callback")loop.call_at(now + 0.1, call_back, 1, loop)loop.call_at(now + 0.2, call_back, 2, loop)loop.call_soon(call_back, 3, loop)await asyncio.sleep(1)if __name__ == '__main__':loop = asyncio.get_event_loop()try:print("进入事件循环")loop.run_until_complete(main(loop))finally:print("关闭循环")loop.close()

运行结果：

进入事件循环
当前的内部时间 148978.593
循环时间 148978.593
注册callback
callback 3  运行时间点 148978.593
callback 1  运行时间点 148978.703
callback 2  运行时间点 148978.796
关闭循环