asyncio
该模块是3.4版本加入的新功能。
先来看一个例子：
def a():
for x in range(3):
print('a.x', x)
def b():
for x in 'abc':
print('b.x', x)
a()
b()
#运行结果：
a.x 0
a.x 1
a.x 2
b.x a
b.x b
b.x c
这个例子是一个典型的串行程序，两个函数调用是在主线程中顺序执行。
有以下几种方法可以让这段程序改为并行：
1. 生成器
2. 多线程
3. 多进程
4. 协程
1）生成器方法：
def a():
for x in range(3):
yield x
def b():
for x in 'abc':
yield x
m = a()
n = b()
for _ in range(3):
print(next(m))
print(next(n))
#运行结果：
0
a
1
b
2
c
使用生成器来实现交替执行。这两个函数都有机会执行，这样的调度不是操作系统的进程、线程完成的，而是用户自己设计的。
2）多线程方法：
import threading,time
def a():
for x in range(3):
time.sleep(0.0001)
print('a.x',x)
def b():
for x in 'abc':
time.sleep(0.0001)
print('b.x',x)
threading.Thread(target=a).start()
threading.Thread(target=b).start()
#运行结果：
a.x 0
b.x a
a.x 1
b.x b
a.x 2
b.x c
主要使用sleep函数强制切换来实现伪并行。
3）多进程方式：
import multiprocessing
def a():
for x in range(3):
print('a.x',x)
def b():
for x in 'abc':
print('b.x',x)
if __name__ == '__main__':
multiprocessing.Process(target=a).start()
multiprocessing.Process(target=b).start()
#运行结果：
a.x 0
a.x 1
a.x 2
b.x a
b.x b
b.x c
多进程方式才是真正的并行。
4）协程方法：
协程，需要使用到 asyncio 标准库，是Python3.4版本加入的新功能，底层基于selectors实现，包括异步IO、事件循环、协程等内容。
事件循环：
事件循环是asyncio提供的核心运行机制。
程序开启一个无限的循环，使用者会把一些函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。
4.1 事件循环基类
asyncio.BaseEventLoop 这个类是一个实现细节，它是asyncio.AbstractEventLoop的子类，不可以直接使用
asyncio.AbstractEventLoop 事件循环的抽象基类，这个类是是线程不安全的
4.2 运行事件循环
asyncio.get_event_loop() 返回一个事件循环对象，是asyncio.BaseEventLoop的实例
asyncio.AbstractEventLoop.stop() 停止运行事件循环
asyncio.AbstractEventLoop.run_forever() 一直运行，直到调用stop()
asyncio.AbstractEventLoop.run_until_complete(future) 运行直到future对象运行完成，返回结果
asyncio.AbstractEventLoop.close() 关闭事件循环
asyncio.AbstractEventLoop.is_running() 返回事件循环的运行状态
asyncio.AbstractEventLoop.is_closed() 如果事件循环已关闭，返回True
4.3 协程
协程不是进程、也不是线程，它是用户空间调度完成并发处理的方式。(同一线程内交替执行其实也是伪并发)
并发指的是在一段时间内做了多少、并行指的是同一时刻有多少同时执行。
进程、线程由操作系统完成调度，而协程是线程内完成调度。它不需要更多的线程，也就没有多线程切换带来的开销。
协程是非抢占式调度，只有一个协程主动让出控制权，另一个协程才会被调度。
协程也不需要锁机制，因为是在同一线程中执行。
多CPU下，可以使用多线程和协程配合，既能进程并发又能发挥协程在单线程中的优势。
Python中协程是基于生成器的。
4.4 协程的使用
4.4.1 Python3.4中使用@asyncio.coroutine 、 yield from
#asyncio Python3.4
import asyncio
@asyncio.coroutine
def foo(x): #生成器函数上面加了协程装饰器之后就转化成协程函数
for i in range(3):
print('foo {}'.format(i))
yield from asyncio.sleep(x) #调用另一个生成器对象
loop = asyncio.get_event_loop() #获得一个时间循环
loop.run_until_complete(foo(1)) #传入一个生成器对象的调用
loop.close()
#运行结果：
foo 0
foo 1
foo 2
[Finished in 3.3s]
此例子在一个生成器函数加了协程装饰器之后，该生成器函数就转化成了协程函数。
4.4.2 Python3.5中使用关键字 async def 、 await ，在语法上原生支持协程
#asyncio Python3.5
import asyncio
async def foo(x): #异步定义,协程定义
for i in range(3):
print('foo {}'.format(i))
await asyncio.sleep(x) #不可以出现yield,使用await替换
print(asyncio.iscoroutinefunction(foo))
loop = asyncio.get_event_loop()
loop.run_until_complete(foo(1)) #传入一个协程对象的调用
loop.close()
#运行结果：
True
foo 0
foo 1
foo 2
[Finished in 3.3s]
async def 用来定义协程函数，iscoroutinefunction(func)判断func函数是否是一个协程函数。协程函数中可以不包含await、async关键字，但不能使用yield关键字。
其它语法：async with，支持上下文的协程
4.4.3 coroutine asyncio.wait(futures, *, loop=None, timeout=None, return_when=ALL_COMPLETED)
等待futures序列中的协程对象执行完成，futures序列不可以为空。
timeout可以用于控制返回前等待的最大秒数，秒数可以是int或浮点数，如果未指定timeout，则无限制。
#wait多个协程对象
import asyncio
@asyncio.coroutine
def a():
for i in range(3):
print('a.x',i)
yield
@asyncio.coroutine
def b():
for i in range(3):
print('b.x',i)
yield
loop = asyncio.get_event_loop()
tasks = [a(),b()]
loop.run_until_complete(asyncio.wait(tasks)) #传入一个协程对象序列
loop.close()
#运行结果：
b.x 0
a.x 0
b.x 1
a.x 1
b.x 2
a.x 2
[Finished in 0.3s]
总结：
传统的多线程、多进程都是系统完成调度，而协程是在进程中的线程内由用户空间调度完成并发处理，主要依靠生成器来实现交替调度。
Python3.4中使用@asyncio.coroutine、yield from调用另一个生成器对象
Python3.5中使用关键字 async def 和 await，且不可以出现yield关键字。