迭代器
isinstance(对象, 类型) 判断xx对象是否是xxx类型的
from collections import Iterable # 可迭代的 from collections import Iterator # 迭代器
判断列表 [1,2,3] 是不是可迭代的
lst = [1, 2, 3] print(isinstance(lst, list))
结果
True # 可迭代的
- 可迭代对象(Iterable):内部包含__iter__().
- 迭代器(Iterator): 内部含有__iter__() __next__()
- dir()来查看一个对象,数据类型中包含了哪些东西
- 迭代器里面一定有__next__(), __iter__()
- 判断是否是可迭代的 迭代器一定是可迭代的
str, list, tuple, set, dictf, range都是可迭代的，int不是可迭代的，如果执行for i in 123:会报错'int' object is not iterable
迭代器的特点:
- 省内存
- 惰性机制（__next__一个出来一个）
- 只能往后拿，不能往前拿
lst = [1, 2, 3] s = "王尼玛" print("__iter__" in dir(s)) # 可迭代的 print("__iter__" in dir(lst)) # 可迭代的 print("__iter__" in dir(123)) # 不可迭代的
结果：
True True False
list是一个Iterable.可迭代的
lst = ["皇阿玛", "皇额娘", "容嬷嬷", "紫薇"] # 获取迭代器 it = lst.__iter__() # 迭代器往外拿元素. __next__() print(it.__next__()) # 皇阿玛 print(it.__next__()) # 皇额娘 print(it.__next__()) # 容嬷嬷 print(it.__next__()) # 紫薇 print(it.__next__()) # 迭代到最后一个元素之后. 再进行迭代就报错了 StopIteration
结果： 皇阿玛 皇额娘 容嬷嬷 紫薇 # 还有个报错
lst = [1, 2, 3] from collections import Iterable # 可迭代的 from collections import Iterator # 迭代器 print(isinstance(lst, Iterable)) print(isinstance(lst, Iterator)) print(isinstance(lst, list))
结果：
True False True
生成器
生成器的本质就是迭代器
生成器的三种创建办法:
- 通过生成器函数
- 通过生成器表达式创建生成器
- 通过数据转换
生成器函数:
- 函数中包含了yield的就是生成器函数
- 注意:生成器函数被执行. 获取到的是生成器. 而不是函数的执行
生成器表达式:
- (结果 for 变量 in 可迭代对象 if 筛选)
取值:
- __next__()
- send(值) 给上一个yield位置传一个值, 第一个和最后一个yield不用传值
- 可以for循环
- list(g)
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
import time def func(): sum = 0 print('in the func...') while 1: yield sum f = func() # 并不会执行func函数 print('abc') time.sleep(20) print(f.__next__())
结果：
abc in the func... 0
只有遇到__next__时才会执行函数，这是生成器的惰性机制造成的。
def func(): print("我是周杰伦") yield "昆凌" # 函数中包含了yield, 当前这个函数就不再是普通的函数了. 是生成器函数 print("我是王力宏") yield "李云迪???" print("我是笛卡尔积") yield "笛卡尔积是谁" print("你好啊") # 最后一个yield之后如果再进行__next__()会报错 g = func() # 通过函数func()来创建一个生成器，生成器的本质是迭代器. 迭代器可以被迭代 生成器可以直接for循环 print(g) print(g.__next__()) print(g.__next__())
结果：
<generator object func at 0x02D26870> 我是周杰伦 昆凌 我是王力宏 李云迪???
return 直接返回结果. 结束函数的调用
yield 返回结果.可以让函数分段执行
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
print((i*2 for i in range(10)))
结果：
<generator object <genexpr> at 0x03378F30>
只是返回了生成器的内存对象，没有调用，就没有生成
a = (i * 2 for i in range(4)) for i in a: print(i)
结果：
0 2 4 6
a = (i * 2 for i in range(4)) print(a.__next__()) print(a.__next__()) print(a.__next__())
结果：
0 2 4
只记录当前的位置，只有一个__next__()方法
生成者和消费者
import time def consumer(name): print("%s 准备吃包子啦!" % name) while True: baozi = yield # 停止，下面的代码先不执行 print("包子[%s]来了,被[%s]吃了!" % (baozi, name)) def producer(name): c = consumer('A') c2 = consumer('B') c.__next__() c2.__next__() print("老子开始准备做包子啦!") for i in range(5): time.sleep(1) print("做了2个包子!") c.send(i) # 跳到yield，执行下面的代码 c2.send(i) producer("zou")
结果：
A 准备吃包子啦! B 准备吃包子啦! 老子开始准备做包子啦! 做了2个包子! 包子[0]来了,被[A]吃了! 包子[0]来了,被[B]吃了! 做了2个包子! 包子[1]来了,被[A]吃了! 包子[1]来了,被[B]吃了! 做了2个包子! 包子[2]来了,被[A]吃了! 包子[2]来了,被[B]吃了! 做了2个包子! 包子[3]来了,被[A]吃了! 包子[3]来了,被[B]吃了! 做了2个包子! 包子[4]来了,被[A]吃了! 包子[4]来了,被[B]吃了!
send
next__() 可以让生成器向下执行一次
send() 也可以让生成器向下执行一次, 给上一个yield传一个值, 第一个不能用send(). 最后一个也不要传值
def func(): print("大碴粥") a = yield "11" print(a) print("狗不理") b = yield "22" print(b) print("大麻花") yield "33" g = func() print(g.__next__()) print(g.send(1)) print(g.send(2))
结果：
大碴粥 11 1 狗不理 22 2 大麻花 33
代码分析：
执行print(g.__next__())，执行到yield "11"结束，左边的a=yield "11"没有执行，因为赋值运算先执行右边的，而生成器遇到yield就停止。这句print(g.send(1))执行a=yield "11"左边的，也就是把send里面的值1赋值给了a，然后到 yield "22"结束
def eat(): print("我吃什么啊") a = yield "馒头" print("a=", a) b = yield "大饼" print("b=", b) c = yield "韭菜盒子" print("c=", c) yield "GAME OVER" gen = eat() # 获取⽣成器 ret1 = gen.__next__() print(ret1) ret2 = gen.send("胡辣汤") print(ret2) ret3 = gen.send("狗粮") print(ret3) ret4 = gen.send("猫粮") print(ret4)
结果：
我吃什么啊 馒头 a= 胡辣汤 大饼 b= 狗粮 韭菜盒子 c= 猫粮 GAME OVER
def func(): yield 11 yield 22 yield 33 yield 44 g = func() lst = list(g) # 可迭代对象 print(lst)
结果：
[11, 22, 33, 44]
