1.1   生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

1.1.1   第一种()生成器

>>> L = [ x * x for x inrange(2,8)]    --列表生成表达式

>>> L

[4, 9, 16, 25, 36, 49]

>>> G = (x * x for x in range(2,8))    --[]符号变成了()，即生成器

>>> G

<generator object <genexpr> at0x2b25180303b8>

>>> next(G)

4

>>> next(G)       --依次计算下个元素

9

>>> next(G)

16

别忘generator也是个可迭代对象

>>> G = ( x * x for x inrange(2,8))

>>> for i in G:

...    print(i)

...

4

9

16

25

36

49

1.1.2   第二种yield生成器

这里yield理解成生产，产生的意思。

generator和函数的执行流程不一样。函数是顺序执行，遇到第一个return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

>>> def step():

...    print('step 1')

...    yield 1

...    print('step 2')

...    yield 2

...    print('step 3')

...    yield 3

...

>>>

>>>

>>> next(step())

step 1

1

>>> next(step())

step 1

1

>>> o = step()

>>> next(o)

step 1

1

>>> next(o)

step 2

2

>>> next(o)

step 3

3

>>> next(o)      --迭代溢出

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

StopIteration

定义一个yield生成器

>>> def fib(max):

...    n, a, b = 0, 0, 1

...    while n < max:

...        yield b

...        a, b = b, a + b

...        n = n + 1

...    return 'done'

...

>>>

>>>

for迭代生成器中的元素

>>> for i in fib(6):

...    print(i)

...

1

1

2

3

5

8

>>>

生成器中return返回值

>>> g = fib(6)

>>> while True:

...    try:

...        x = next(g)

...        print('x =',x)

...    except StopIteration as e:

...        print('Generator return value: ',e.value)

...        break

...

x = 1

x = 1

x = 2

x = 3

x = 5

x = 8

Generator return value:  done

1.2   迭代器

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

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

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

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

可以使用isinstance()判断一个对象是否是Iterable对象：

>>> fromcollections import Iterable

>>> isinstance([], Iterable)

True

>>> isinstance({}, Iterable)

True

>>> isinstance('abc', Iterable)

True

>>> isinstance(((1, 2), (3, 4)),Iterable)

True

>>> isinstance((x for x inrange(10)), Iterable)

True

>>> isinstance(100, Iterable)

False

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

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

>>> fromcollections import Iterator

>>> isinstance([], Iterator)

False

>>> isinstance({}, Iterator)

False

>>> isinstance(((1, 2), (3, 4)),Iterator)

False

>>> isinstance((x for x inrange(10)), Iterator)

True

 

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)

True

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

True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

 

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:

   pass

实际上完全等价于：

# 首先获得Iterator对象:

it = iter([1, 2, 3, 4,5])

# 循环:

while True:

   try:

       # 获得下一个值:

       x = next(it)

   except StopIteration:

       # 遇到StopIteration就退出循环

       break