Python迭代器和生成器

1、List Conprehensions

列表生成式是python中内置的用来创建list的表达式、
如果我们要生成简单的list可以直接使用range函数来完成。

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

但是有时候我们要生成复杂的list怎么办呢？比如我们生成一个[1^2, 2^2, 3^2...]的list。

>>> my_list = []
>>> for item in range(10):
...     my_list.append(item * item)
...
>>> my_list
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>

上面的代码都不够简洁，python中的列表生成式可以一行解决。

>>> [x * x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>

在书写生成式表达式时，将要生成的元素放在前面，后面是for循环。
还可以在创建列表的同时进行简单的过滤。

>>> [x * x for x in range(10) if x%2 == 0]
[0, 4, 16, 36, 64]
>>>

还可以实现全排列

>>> [(x,y) for x in '123' for y in '456']
[('1', '4'), ('1', '5'), ('1', '6'), ('2', '4'), ('2', '5'), ('2', '6'), ('3', '4'), ('3', '5'), ('3', '6')]
>>>

2、Iterables

当我们创建了一个列表，我们可以依次遍历它，依次遍历的过程就是迭代。

>>> my_list = [1, 2, 3]
>>> for i in my_list:
...     print i
...
1
2
3

my_list就是一个可迭代对象，当我们使用上面说的列表生成式创建一个列表时，该列表也是一个可迭代的。

>>> my_list = [x * x for x in range(3)]
>>> for i in my_list:
...     print i
...
0
1
4

对于任何可迭代的对象都可以使用for in来进行迭代。
但是这样做有一个缺点就是：当我们的数据非常多的时候比如一个大列表，这个列表将会被读到内存中，会占用非常多的内存，有时候硬件是达不到的。

3、 Generators

对一个包含大量数据的列表，不仅占用很大的内存，如果我们使用到的就只有某一小部分数据就会导致内存的浪费。
如果列表中的元素可以根据某种算法推导出来，而不是将所有元素都存放在列表中，从而可以节省很多内存空间。这样一边循环一边计算的机制叫做生成器(Generator)。
创建一个Generator直接可以将上面的列表生成式的[]换成()就可以了。python中提供了生成器表达式，它是对列表和生成器的一种泛化，生成器表达式在运行的时候，并不会将整个输出序列都呈现出来，而是会估值为迭代器，这个迭代器每次可以根据生成器表达式产生一项数据。

>>> L1 = [x * x for x in range(10)]
>>> L2 = (x * x for x in range(10))
>>> L1
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> L2
<generator object <genexpr> at 0x000000000347F7E0>
>>>

从打印结果可以看出L2是一个Generator，可以使用next()方法打印每一个元素。

>>> L2.next()
0
>>> L2.next()
1
>>> L2.next()
4
>>> L2.next()
9
>>> L2.next()
16
>>> L2.next()
....
>>> L2.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

如果没有元素了就会抛出异常。
Generator也是可迭代的，但是只能迭代一次。

>>> L2 = (x * x for x in range(10))
>>> for i in L2:
...     print i
...
0
1
4
9
16
25
36
49
64
81
>>>

4、生成器和迭代器区别

迭代器是一个更普遍的概念，如果一个类中有next()方法和返回自身return self的__iter__()方法，这个类的对象就是一个Iterator。
所有的生成器是一个迭代器，但是反过来就不是。生成器通过调用具有一个或多个yield表达式（在Python 2.5和更早版本中的yield语句）的函数构建。

>>> def squares(start, stop):
...     for i in range(start, stop):
...             yield i * i
...
>>>
>>> generator = squares(1, 3)
>>> generator
<generator object squares at 0x000000000347F7E0>
>>>

当然还可以使用生成器表达式直接生成一个Generator。
但是有时候你需要一个定制的迭代器，定义一个类，该类实现next() 和 __iter__()方法就可以。

class Squares(object):
    def __init__(self, start, stop):
        self.start = start
        self.stop = stop
    def __iter__(self):
        return self
    def next(self):
        if self.start >= self.stop:
            raise StopIteration
        current = self.start * self.start
        self.start += 1
        return current

5、使用yield关键字创建生成器

如果一个函数包含了yield关键字，这个函数就是一个生成器。但是Generator和函数的执行流程是不一样的。函数是顺序执行，遇到return语句或者执行完毕后就返回，如果变成了Generator后，每次调用next()函数开始执行，遇到yield返回，下次接着从上次返回位置进行执行。

>>> def fun():
...     print 'run 1'
...     yield 1
...     print 'run 2'
...     yield 2
...
>>> g = fun()
>>> g.next()
run 1
1
>>> g.next()
run 2
2
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

我们使用关键字yield定义了一个Generator，在执行的时候，遇到yield关键字就会返回，再次调用就从上次返回的地方开始。