生成器

1.什么是生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定有限的。而且，创建一个包含100万个元素的列表，要占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都要白白浪费，所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续元素呢：这样就可以不用创建完整的list，从而节省大量的空间，在python中，这种一边循环一边计算的机制，称为生成器：generator。

2.创建生成器方法1

要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的【】改为（）

L=[x*2 for x in range(5)]
L=[0,2,4,6,8]


G=(x*2 for x in range(5))
next(G)
0
next(G)
2
next(G)
4
.....

创建L和G的区别仅在于最外层的【】和（），L是一个列表，而G是一个生成器。我们可以直接打印出L的每一个元素，而G要通过next（）函数获得生成器的下一个返回值。
生成器保存的是算法，每次调用next（G），就计算出G的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出stopiteration异常。当然，也可以使用for循环，因为生成器是可迭代对象，所有，我们创建了一个生成器后，基本上永远不会调用next（），而是通过for循环来迭代它，并且不需要关心stoplteration异常。

3.创建生成器方法2

generator非常强大，如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。
比如，斐波那契数列，除第一个和第二个数外，任意各个数都可以由前两个数相加得到。
斐波那契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(times):
  n=0
  a,b=0,1
  while<times:
    print(b)
    a,b=b,a+b
    n+=1
  return 'done'




fib(5)
1
1
2
3
5
'done'

仔细观察，可以看出fib函数实际上是定义了斐波那契数列的推算规则，可以从第一个元素开始，推算出后继任意的元素，这种逻辑其实非常类似generator
也就是说，上面的函数和generator仅一步之遥，要把fib函数变成generator，只需要把print（b）改为yield b就可以：

def fib(times):
  n=0
  a,b=0,1
  while n<times:
    yield b
    a,b=b,a+b
    n+=1
  return 'done'



F=fib(5)

next(F)
1
next(F)
1
next(F)
2
next(F)
3
next(F)
5

也可以使用for循环来迭代：

for n in fib(5):
  print(n)
  
  
1
1
2
3
5

但是用for循环调用generator时，发现拿不到generator的return语句的返回值，如果想要拿到返回值，必须捕获stoplteration错误，返回值包含在stoplteration的value中：

g=fib(5)
while True:
  try:
    x=next(g)
    print("value:%d"%x)
  except StopIteration as e:
    print("生成器返回值：%s"%e.value)
    break
    
    
value:1
value:1
value:2
value:3
value:5
生成器返回值：done

4.send

例：执行到yield时，gen函数作用暂时保存，返回i的值；temp接收下次c.send("python"),send发送过来的值，c.next()等价c.send(None)

def gen():
  i=0
  while i<5:
    temp=yield i
    print(temp)
    i+=1
    
    
    
f=gen()
next(f)
0
next(f)
None
1
next(f)
None
2
next(f)
None
3
next(f)
None
4
next(f)
None
异常

使用_____next_____()方法

f=gen()


f.__next__()
0
f.__next__()
None
1
f.__next__()
None
2
f.__next__()
None
3
f.__next__()
None
4
f.__next__()
None
异常

使用send

f=gen()
f.__next__()
0
f.send('nihao')
nihao
1
f.__next__()
None
2
f.send('nihao')
nihao
3

总结

生成器是这用一个函数，它记住上一次返回时在函数体中的位置，对生成器函数的第二次（或第n次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。
生成器不仅记住了数据状态；生成器还记住了他在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。
生成器的特点：

1. 节约内存
2. 迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的。

迭代器

迭代是访问集合元素的一种方式。迭代器是一个可以记住便利的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结。迭代器只能向前不能后退。

1.可迭代对象

以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：iterable

2.判断是否可以迭代

可以用isinstance（）判断一个对象是否是iterable对象：

from collections import Iterable

isinstance([],Iterable)
True

isinstance({},Iterable)
True

isinstance('abc',Iterable)
True

isinstance((x for x in range(10)),Iterable)
True

isinstance(100,Iterable)
False

生成器不但可以作用于for循环，还可以被next（）函数不断调用并返回下一个值，直到最后抛出Stoplteration错误表示无法继续返回下一个值。

3.迭代器

可以被next（）函数调用并不断返回下一个值得对象称为迭代器：lterator。

可以使用isinstance（）判断一个对象是否是iterator对象：

from collections import Iterator

isinstance((x for x in range(10)),Iterator)
True

isinstance([],Iterator)
False

isinstance({},Iterator)
False

isinstance('abc',Iterator)
False

isinstance(100,Iterator)
False

4.iter()函数

生成器都是迭代器对象，但list、dict、str虽然都是可迭代，却不是迭代器。

把list、dict、str等由可迭代变为迭代器可以使用iter（）函数：

isinstance(iter([]),Iterator)
True

isinstance(iter('abc'),Iterator)
True

总结

• 凡是可以作用于for循环的对象都是可迭代类型；
• 凡是可作用于next（）函数的对象都是迭代器类型；
• 集合数据类型如list、dict、str等是可迭代但不是迭代器，但可以通过iter（）函数获得一个迭代器对象。