asyncio 异步请求（python 3.5 新引用语法）
python 3.4 引入了协程的概念。在 python 3.5 中确定了协程的语法
- event_loop 事件循环：程序开启一个无限的循环，程序员会把一些函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。
- coeoutine 协程：协程对象，指一个使用 async 关键字定义的函数，它的调用不会立即执行函数，而是返回一个协程对象。写成对象需要注册到事件循环中，由事件循环调用。
- task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。
- future：代表将来执行或没有执行的任务的结果。它和 task 没有本质上的区别。
- async / await 关键字：python 3.5 用于定义协程的关键字，async定义一个协程，await 用于挂起阻塞的异步调用接口。
定义一个协程
使用 async 关键字定义协程。
import time
import asyncio
# 定义时间函数（计算程序执行时间差）
now = lambda: time.time()
async def func1(x):
print('test', x)
start = now()
coroutine = func1(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)
print('TIME', now() - start)
# 返回值：
"""
test 2
TIME 0.0019989013671875
"""
通过 async 关键定义了一个协程，协程也是一种对象， 协程不能直接运行，需要把写成加入到时间循环（loop）, 由 loop 在适当的时候调用协程，asyncio.get_event_loop 方法可以创建一个事件循环，然后使用 run_until_complete 将协程注册到事件循环，并启动事件循环。
创建一个 task
协程对象不能直接运行，在注册循环时，其实是 run_until_complete 方法将协程包装成一个任务（task）对象。所谓 task 对象是 Future 类的子类。保存了协程运行后的状态，用于未来获取协程的结果。
创建task
- task = asyncio.ensure_future(coroutine)
- task = loop.create_task(coroutine)
代码如下：
import asyncio
import time
new = lambda: time.time()
start = new()
async def func1(x):
print('waiting:', x)
coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
print(task)
loop.run_until_complete(task)
print(task)
loop.close()
print('Programe finished in %s' % ( start - new()))
# 返回值：
"""
<Task pending coro=<func1() running at F:/……/async_test.py:24>>
waiting: 2
<Task finished coro=<func1() done, defined at F:/脱产学习2017.10.27/兄弟连python/haolong/alice_code/scrapy_spider/requests_advance/async_test.py:24> result=None>
Programe finished in -0.0019981861114501953
"""
创建 task 后，task 在加入事件循环之前是 pending 状态（即等待状态），当task被执行完毕了，就变为 finished 状态
绑定回调
在 task 执行完毕的时候可以获取执行的结果，回调的最后一个参数是 future 对象，通过该对象可以获取协程返回值。如果回调需要多个参数，可以通过偏函数导入。
import asyncio
import time
now = lambda: time.time()
start = now()
async def func1(x):
print('waiting', x)
return 'Done after{}s'.format(x)
def callback(future):
print('Callback: ',future.result())
coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
task.add_done_callback(callback)
loop.run_until_complete(task)
loop.close()
print('Program finished in {}s'.format(start-now()))
# 返回值：
"""
waiting 2
Callback: Done after2s
Program finished in -0.0009989738464355469s
"""
coroutine 执行结束时会调用回调函数，并通过参数 future 获取协程执行的结果。我们创建的 task 和 回调里的 future ，实际上是同一个对象。async 函数中的 return 的结果再回掉函数中被 futuren.result() 调用。
future 与 result
回调中使用了 future 对象的 result 方法。
import asyncio
import time
now = lambda: time.time()
start = now()
async def func1(x):
print('waiting {}'.format(x))
return 'Done after {}s'.format(x)
coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
loop.run_until_complete(task)
print('task return value {}'.format(task.result()))
print('Program finished in {}s'.format(start - now()))
阻塞 和 await
使用 async 可以定义协程对象，使用 await 可以针对协程中耗时的操作进程挂起，就像生成器中的 yield 一样， 函数让出控制权，协程遇到 await 时，事件循环将会挂起该协程，执行别的协程。直到其他的协程也挂起或者执行完毕，再进行下一个协程的执行。
耗时的操作一般是一些 IO 操作，例如网络请求，文件读取等。我们使用asyncio.sleep 函数来模拟 IO 操作。协程的目的也是让这些 IO 操作异步化。
import asyncio
import time
now = lambda: time.time()
async def func1(x):
print('waiting', x)
await asyncio.sleep(1)
return 'Done after {}s'.format(x)
start = now()
coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
loop.run_until_complete(task)
loop.close()
print('task return value {}'.format(task.result()))
print('Program finished in {}'.format(now() - start))
并发与并行
- 并发：通常指多个任务需要同时进行。
- 并行：指同一时刻有多个任务执行。
以下棋为例：并发是指一对一，但是一个人同时对战多个人，而并行则是一对一，但是有很多桌在同时对战。
asyncio 实现并发，就需要多个协程来完成任务，当有阻塞的时候就 await ，然后其他协程继续工作。创建多个协程的列表，然后将这些列表注册到事件循环中。
import asyncio
import time
now = lambda: time.time()
async def func1(x):
print('waiting {}'.format(x))
await asyncio.sleep(x)
return 'Done after {}s'.format(x)
start = now()
coroutine1 = func1(1)
coroutine2 = func1(2)
coroutine3 = func1(3)
coroutine4 = func1(4)
tasks = [
asyncio.ensure_future(coroutine1),
asyncio.ensure_future(coroutine2),
asyncio.ensure_future(coroutine3),
asyncio.ensure_future(coroutine4)
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
for task in tasks:
print('task return value {}'.format(task.result()))
print('program finished in {}s'.format(now() - start))
# 返回值
"""
waiting 1
waiting 2
waiting 3
waiting 4
task return value Done after 1s
task return value Done after 2s
task return value Done after 3s
task return value Done after 4s
program finished in 4.002517223358154s
"""
程序总执行事件为 4 秒。
- 如果是同步执行，至少需要 10 秒；
- 此时使用 asyncio 实现了并发，执行时间只需要4秒，asyncio.wait(tasks) 接收 task 列表。也可以使用asyncio.gather(*tasks) 接收一堆task，
