python--迭代器、isinstance、生成器、send
原创
©著作权归作者所有：来自51CTO博客作者邹邹很busy的原创作品，请联系作者获取转载授权，否则将追究法律责任
迭代器
isinstance(对象, 类型) 判断xx对象是否是xxx类型的
from collections import Iterable # 可迭代的
from collections import Iterator # 迭代器
判断列表 [1,2,3] 是不是可迭代的
lst = [1, 2, 3]
print(isinstance(lst, list))
结果
- 可迭代对象(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)) # 不可迭代的
结果：
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))
结果：
生成器
生成器的本质就是迭代器
生成器的三种创建办法:
- 通过生成器函数
- 通过生成器表达式创建生成器
- 通过数据转换
生成器函数:
- 函数中包含了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__())
结果：
只有遇到__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：
结果：
<generator object <genexpr> at 0x03378F30>
只是返回了生成器的内存对象，没有调用，就没有生成
a = (i * 2 for i in range(4))
for i in a:
print(i)
结果：
a = (i * 2 for i in range(4))
print(a.__next__())
print(a.__next__())
print(a.__next__())
结果：
只记录当前的位置，只有一个__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))
结果：
代码分析：
执行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)
结果：
