分类： Python技术

协程

目录
一、yield
1.实现
二、greenlet
1. 简介
2.用法
3.实现
三、gevent
1.简介
2.用法
3.实现
4.geventa的monkey模块
四、使用asyncio实现协程
1.格式
2.实现
3.aiohttp实现多任务异步协程
一、yield
协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元
1.实现
import time

def task_1():
while True:
print(“—1—-“)
time.sleep(0.1)
yield

def task_2():
while True:
print(“—2—-“)
time.sleep(0.1)
yield

def main():
t1 = task_1()
t2 = task_2()
# 先执行t1，当t1中遇到yield的时候，退出函数
# 然后执行t2，当它遇到yield的时候，再次切换到t1中
# 这样t1/t2/t1/t2的交替运行，*终实现了多任务….协程
while True:
next(t1)
next(t2)

if __name__ == “__main__”:
main()
二、greenlet
1. 简介
为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单。
需要人工切换
依赖：pip install greenlet
2.用法
from greenlet import greenlet

实例化greenlet对象
g = greenlet(func):
调度:
g.switch()
3.实现
from greenlet import greenlet
import time

def test1():
while True:
print(“—A–“)
gr2.switch() # 切换任务
print(‘延时0.5秒’)
time.sleep(0.5)

def test2():
while True:
print(“—B–“)
gr1.switch() # 切换任务
print(‘延时0.5秒’)
time.sleep(0.5)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

# 切换到gr1中运行
gr1.switch()

三、gevent
1.简介
对greentlet的进一步封装
原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。
由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO
依赖：pip install gevent
2.用法
import gevent

实例化对象：

g = gevent.spown(run=None, *args, **kwargs)
run:接收的是一个函数
*args, **kwargs：传递到函数中的参数
g.join():等待协程执行结束
同时实例化多个对象：

gevent.joinall(objects=None)
objects:包含实例化对象的列表
3.实现
import gevent
import time

# monkey.patch_all() # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块

def f1(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5) # 导入gevent自己模块的sleep

def f2(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5) # 导入gevent自己模块的sleep

def f3(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5) # 导入gevent自己模块的sleep

print(“—-1—“)
g1 = gevent.spawn(f1, 5)
print(“—-2—“)
g2 = gevent.spawn(f2, 5)
print(“—-3—“)
g3 = gevent.spawn(f3, 5)
print(“—-4—“)
g1.join()
print(‘g1 is ok’)
g2.join()
print(‘g2 is ok’)
g3.join()
print(‘g3 is ok’)

# gevent.joinall([
# gevent.spawn(f1, 5),
# gevent.spawn(f2, 5),
# gevent.spawn(f3, 5),
# ])
4.geventa的monkey模块
解决延时操作只能使用gevent中的延时操作问题
本质上将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()
今后导入延时模块可以使用time，当碰到延时操作时，会自动将程序中用到的耗时操作的代码，换为gevent中自己实现的模块。
四、使用asyncio实现协程
1.格式
import asyncio

1.async def func（）：
…
# 当有耗时操作的时候切换协程
await asyncio.sleep(x)
…

2.a = func（）：调用之后返回的就是一个协程对象

3.创建协程的时间循环对象：
loop = asyncio.get_event_loop()

4.创建task对象的两种方式：
task = loop.create_task(a)
task = asyncio.ensure_future(a)

5.执行task对象
loop.run_until_complete(asyncio.wait(fs))
fs:可迭代对象，封装了多个任务对象，一般为列表

2.实现
import asyncio
import time

async def request(url):
print(‘正在下载’, url)
# 在异步协程中如果出现了同步模块相关的代码，那么就无法实现异步。
# time.sleep(2)
# 当在asyncio中遇到阻塞操作必须进行手动挂起
await asyncio.sleep(2)
print(‘下载完毕’, url)

start = time.time()
urls = [
‘www.baidu.com’,
‘www.sogou.com’,
‘www.goubanjia.com’
]

# 任务列表：存放多个任务对象
loop = asyncio.get_event_loop()
stasks = []
for url in urls:
# 创建协程对象
c = request(url)
# 创建task对象
task = asyncio.ensure_future(c)
# task = loop.create_task(c)
# 追加到列表中
stasks.append(task)

# 需要将任务列表封装到wait中
loop.run_until_complete(asyncio.wait(stasks))

print(time.time() – start)

运行结果：

正在下载 www.baidu.com
正在下载 www.sogou.com
正在下载 www.goubanjia.com
下载完毕 www.baidu.com
下载完毕 www.sogou.com
下载完毕 www.goubanjia.com
2.0125160217285156

3.aiohttp实现多任务异步协程
上述中必须使用await asyncio.sleep(2)是因为它是基于异步的延时操作，使用time.sleep()是同步的延时操作，无法实现多任务并发执行
同理，requests.get是基于同步，必须使用基于异步的网络请求模块进行指定url的请求发送
aiohttp:基于异步网络请求的模块
依赖：pip install aiohttp
例：

# 使用该模块中的ClientSession
import requests
import asyncio
import time
import aiohttp # 安装包

start = time.time()

urls = [‘http://www.sougou.com’, ‘http://www.goubanjia.com’, ‘http://www.baidu.com’]
# for i in range(10):
# urls.append(‘http://www.baidu.com’)
print(urls)

async def get_page(url):
async with aiohttp.ClientSession() as session:
# get()、post():
# 还可以携带的参数：headers,params/data,proxy=’http://ip:port’
async with await session.get(url) as response:
# text()返回字符串形式的响应数据
# read()返回的二进制形式的响应数据
# json()返回的就是json对象
print(‘开始获取’, url)
# 注意：获取响应数据操作之前一定要使用await进行手动挂起
page_text = await response.text()
# print(‘结束获取’, page_text)
print(‘结束获取’, url)

tasks = []

loop = asyncio.get_event_loop()
for url in urls:
c = get_page(url)
task = asyncio.ensure_future(c)
tasks.append(task)

loop.run_until_complete(asyncio.wait(tasks))

end = time.time()

print(‘总耗时:’, end – start)

执行结果：

[‘http://www.sougou.com’, ‘http://www.goubanjia.com’, ‘http://www.baidu.com’]
开始获取 http://www.baidu.com
开始获取 http://www.goubanjia.com
结束获取 http://www.goubanjia.com
结束获取 http://www.baidu.com
开始获取 http://www.sougou.com
结束获取 http://www.sougou.com
总耗时: 0.3390941619873047

高级特性：迭代器

文章大部分参考来源：No-Coder’s Blog
1. 可迭代对象
我们已经知道可以对list、tuple、str等类型的数据使用for…in…的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。

但是，是否所有的数据类型都可以放到for…in…的语句中，然后让for…in…每次从中取出一条数据供我们使用，即供我们迭代吗？

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-

for i in 100:
print i

# >>> TypeError: ‘int’ object is not iterable
# int类型的对象是不可迭代的

class MyList(object):
def __init__(self):
self.names = []

def add(self, value):
self.names.append(value)

mylist = MyList()
mylist.add(‘1’)
mylist.add(‘2’)
mylist.add(‘3’)

for i in mylist:
print i

# >>> TypeError: ‘MyList’ object is not iterable
# MyList类型的对象是不可迭代的

2. 如何判断一个对象是否可迭代
“””
可以使用isinstance来判断对象是否为可迭代的
“””

from collections import Iterable

isinstance([], Iterable)
# True

isinstance({}, Iterable)
# True

isinstance(‘abc’, Iterable)
# True

isinstance(mylist, Iterable)
# False

isinstance(100, Iterable)
# False
3. 可迭代对象的本质
“”“
让我们来看下能够被for…in循环取值的类型到底都有什么相同的特性？
使用dir发现list tuple dict 这些数据类型都有一个函数叫__iter__函数是不是实现了这个函数 我们对应创建的内容就是可迭代的
”“”

class MyList(object):
def __init__(self):
self.names = []

def add(self, value):
self.names.append(value)

def __iter__(self):
pass

mylist = MyList()
mylist.add(‘1’)
mylist.add(‘2’)
mylist.add(‘3’)

for i in mylist:
print i

# >>> TypeError: iter() returned non-iterator of type ‘NoneType’
# MyList类型的对象iter函数返回的不是关于iterator的对象
# 那我们再去修改一下

class MyList(object):
def __init__(self):
self.names = []

def add(self, value):
self.names.append(value)

def __iter__(self):
return MyIterator(self)

class MyIterator(object):
def __init__(self, mylist):
self.mylist = mylist
self.current = 0

def __next__(self):
if self.current < len(self.mylist.container):
item = self.mylist.container[self.current]
self.current += 1
return item
else:
raise StopIteration

mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
for i in mylist:
print(i)

# 1 2 3
# 成功我们先不管MyIterator是什么，我们目前关心的是只要对应的对象中实现了iter并且返回了对应的迭代器对象这个时候我们实现的对象就可以称之为可迭代的

4. iter()以及next()
li_iter = iter(li)
next(li_iter)
# 11
next(li_iter)
# 22
next(li_iter)
# 33
next(li_iter)
# 44
next(li_iter)
# 55
next(li_iter)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
StopIteration

“””
list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的__iter__方法。而__iter__方法则返回包含next函数的迭代器对象，然后我们使用迭代器对象的next方法不停的取出下一个值，直到raise为止
“””
5. 如何判断一个对象是否为迭代器
from collections import Iterator

isinstance([], Iterator)
# False

isinstance(iter([]), Iterator)
# True

isinstance(iter(“abc”), Iterator)
# True
6. 迭代器iterator
“””
通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__方法（Python3中是对象的__next__方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的__next__方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。
总结来说：一个实现了__iter__方法和__next__方法的对象，就是迭代器。
“””

class MyList(object):

def __init__(self):
self.container = []

def add(self, item):
self.container.append(item)

def __iter__(self):
“””返回一个迭代器”””
return MyIterator(self)

class MyIterator(object):

def __init__(self, mylist):
self.mylist = mylist
self.current = 0

def __next__(self):
if self.current < len(self.mylist.container):
item = self.mylist.container[self.current]
self.current += 1
return item
else:
raise StopIteration

if __name__ == “__main__”:
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)

for i in mylist:
print(i)
7. for…..in的本质
for item in items  循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器Iterator，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

8. 迭代器简单的练习题
# 斐波那契实现

class Feb(object):
def __init__(self,num):
self.num = num
self.index = 0
self.a = 0
self.b = 1

def __iter__(self):
return self

def next(self):
if self.index < self.num:
v = self.a
self.a, self.b = self.a + self.b, self.a
self.index += 1
return v

else:
raise StopIteration

if __name__ == ‘__main__’:
f = Feb(20)
for i in f:
print i
# 倒叙取值

class Reverse(object):

def __init__(self,list):
self.num = len(list)
self.target = list

def __iter__(self):
return self

def next(self):
self.num -= 1
if self.num >= 0:
return self.target[self.num]
else:
raise StopIteration

if __name__ == ‘__main__’:
list = [1, 2, 3, 4, 5, 6, 7, 8]
r = Reverse(list)
for i in r:
print i
学习到这我们总结一下：

可迭代对象（实现了iter方法，iter方法返回迭代器对象）

迭代器对象（实现了iter以及next方法）