协程
迭代器
-
迭代: 是访问集合元素的一种方式,用 for…in…从 list、tuple、str等类型中依次取数据,这种遍历也称之为迭代
-
迭代对象:可以通过 for…in…这类语句迭代读取数据的对象
-
迭代器:是一个可以记住遍历的位置的对象。
实现一个可迭代对象
import time
from collections import Iterable
from collections import Iterator
class Classmate(object):
def __init__(self):
self.names = list()
self.current_num = 0
def add(self, name):
self.names.append(name)
def __iter__(self):
"""如果想要一个对象称为一个 可以迭代的对象,即可以使用for,那么必须实现__iter__方法"""
return self
# 调用iter(xxobj)的时候 只要__iter__方法返回一个 迭代器即可
# 至于是自己 还是 别的对象都可以的, 但是要保证是一个迭代器
# (即实现了 __iter__ __next__方法)
def __next__(self):
if self.current_num < len(self.names):
ret = self.names[self.current_num]
self.current_num += 1
return ret
else:
raise StopIteration
classmate = Classmate()
classmate.add("老王")
classmate.add("王二")
classmate.add("张三")
# print("判断classmate是否是可以迭代的对象:", isinstance(classmate, Iterable))
# classmate_iterator = iter(classmate)
# print("判断classmate_iterator是否是迭代器:", isinstance(classmate_iterator, Iterator))
# print(next(classmate_iterator))
for name in classmate:
print(name)
time.sleep(1)
iter()函数 与 next()函数
- list、tuple等都是可迭代对象,我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的 __ iter __ 方法。
如何判断一个对象是否是迭代器
可以使用 isinstance() 判断一个对象是否是 Iterator 对象
In [56]: from collections import Iterator
In [57]: isinstance([], Iterator)
Out[57]: False
In [58]: isinstance(iter([]), Iterator)
Out[58]: True
In [59]: isinstance(iter("abc"), Iterator)
Out[59]: True
迭代器Iterator
一个实现了 __iter__方法和__next__方法的对象,就是迭代器。
for…in…循环的本质
- for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器,然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item,当遇到StopIteration的异常后循环结束。
斐波拉契数列(Fibonacci)
- 数列中第一个数为0,第二个数为1,其后的每一个数都可由前两个数相加得到:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …
nums = list()
a, b, i = 0, 1, 0
while i < 10:
nums.append(a)
a, b = b, a + b
i += 1
for num in nums:
print(num)
迭代器实现斐波那契数列
class Fibonacci(object):
def __init__(self, all_num):
self.all_num = all_num
self.current_num = 0
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
if self.current_num < self.all_num:
ret = self.a
self.a, self.b = self.b, self.a+self.b
self.current_num += 1
return ret
else:
raise StopIteration
fibo = Fibonacci(10)
for num in fibo:
print(num)
生成器
- 生成器是一类特殊的迭代器。
生成器实现斐波那契数列
- 简单来说:只要在def中有yield关键字的 就称为 生成器
def create_num(all_num):
print("----1---")
# a = 0
# b = 1
a, b = 0, 1
current_num = 0
while current_num < all_num:
print("----2---")
# print(a)
yield a # 如果一个函数中有yield语句,那么这个就不在是函数,而是一个生成器的模板
print("----3---")
a, b = b, a+b
current_num += 1
print("----4---")
# 如果在调用create_num的时候,发现这个函数中有yield那么此时,不是调用函数,而是创建一个生成器对象
obj = create_num(10)
ret = next(obj)
print(ret)
ret = next(obj)
print(ret)
obj2 = create_num(2)
ret = next(obj2)
print(ret)
# for num in obj:
# print(num)
总结
- 使用了yield关键字的函数不再是函数,而是生成器。(使用了yield的函数就是生成器)
- yield关键字有两点作用:
- 保存当前运行状态(断点),然后暂停执行,即将生成器(函数)挂起
- 将yield关键字后面表达式的值作为返回值返回,此时可以理解为起到了return的作用
- 可以使用next()函数让生成器从断点处继续执行,即唤醒生成器(函数)
通过异常判断生成器已经结束
def create_num(all_num):
# a = 0
# b = 1
a, b = 0, 1
current_num = 0
while current_num < all_num:
# print(a)
yield a # 如果一个函数中有yield语句,那么这个就不在是函数,而是一个生成器的模板
a, b = b, a+b
current_num += 1
return "ok...."
obj2 = create_num(50) # 这时调用,不是在调用函数,而是创建一个生成器对象
while True:
try:
ret = next(obj2)
print(ret)
except Exception as ret:
print(ret.value)
break
用send启动生成器
- 可以使用next()函数来唤醒生成器继续执行外,还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据
def create_num(all_num):
a, b = 0, 1
current_num = 0
while current_num < all_num:
ret = yield a
print(">>>ret>>>>", ret)
a, b = b, a+b
current_num += 1
obj = create_num(10)
# obj.send(None) # send一般不会放到第一次启动生成器,如果非要这样做 那么传递None
ret = next(obj)
print(ret)
# send里面的数据会 传递给第5行,当做yield a的结果,然后ret保存这个结果,,,
# send的结果是下一次调用yield时 yield后面的值
ret = obj.send("hahahha")
print(ret)
协程—yield
- 协程是python个中另外一种实现多任务的方式
- 通俗的理解:在一个线程中的某个函数,可以在任何地方保存当前函数的一些临时变量等信息,然后切换到另外一个函数中执行,注意不是通过调用函数的方式做到的,并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定
使用yield完成多任务
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的时候,再返回到24行,然后
# 执行t2,当它遇到yield的时候,再次切换到t1中
# 这样t1/t2/t1/t2的交替运行,最终实现了多任务....协程
while True:
next(t1)
next(t2)
if __name__ == "__main__":
main()
协程—greenlet
- 为了更好使用协程来完成多任务,python中的greenlet模块对其封装,从而使得切换任务变的更加简单
- ubantu 中安装greenlet:sudo pip3 install greenlet
使用greenlet完成多任务
from greenlet import greenlet
import time
def test1():
while True:
print("---A--")
gr2.switch()
time.sleep(0.5)
def test2():
while True:
print("---B--")
gr1.switch()
time.sleep(0.5)
gr1 = greenlet(test1)
gr2 = greenlet(test2)
#切换到gr1中运行
gr1.switch()
协程—gevent
- python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent
- ubantu中安装:pip3 install gevent
genvent实现多任务
import gevent
import time
def f1(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5)
def f2(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5)
def f3(n):
for i in range(n):
print(gevent.getcurrent(), i)
# time.sleep(0.5)
gevent.sleep(0.5)
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()
g2.join()
g3.join()
genvent打补丁
import gevent
import time
from gevent import monkey
monkey.patch_all() # 打补丁,将下面的延时操作变成 gevent.sleep(0.5)
def f1(n):
for i in range(n):
print(gevent.getcurrent(), i)
#用来模拟一个耗时操作,注意不是time模块中的sleep
time.sleep(0.5) # 若没有上面的补丁,则这句话没效果,就是安顺序执行,不是多任务
#遇到延时等待,切换到下一个执行
def f2(n):
for i in range(n):
print(gevent.getcurrent(), i)
time.sleep(0.5)
def f3(n):
for i in range(n):
print(gevent.getcurrent(), i)
time.sleep(0.5)
gevent.joinall([
gevent.spawn(f1, 5),
gevent.spawn(f2, 5),
gevent.spawn(f3, 5)
])
# g1.join()
# g2.join()
# g3.join()
- gevent任务切换是需要堵塞,如,当执行到 f1 里的 time.sleep(0.5) 时, gevent就发现遇到了延时,程序处于等待状态,这时, gevent 就会切换到 f2 中执行,同理,就实现了多任务(并发)
简单总结
1.进程是资源分配的单位
2.线程是操作系统调度的单位
3.进程切换需要的资源很最大,效率很低
4.线程切换需要的资源一般,效率一般(当然了在不考虑GIL的情况下)
5.协程切换任务资源很小,效率高
6.多进程、多线程根据cpu核数不一样可能是并行的,但是协程是在一个线程中 所以是并发