python--迭代器、isinstance、生成器、send

迭代器

 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

结果：

<generator object <genexpr> at 0x03378F30>

只是返回了生成器的内存对象，没有调用，就没有生成

a = (i * 2 for i in range(4))
for i in a:
print(i)

结果：

0
2
4
6a = (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 OVERdef func():
yield 11
yield 22
yield 33
yield 44


g = func()
lst = list(g) # 可迭代对象
print(lst)

结果：

[11, 22, 33, 44]