py8 列表生成式 迭代器 生成器

列表生成式，迭代器&生成器

列表生成式

列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每个值加1，你怎么实现？你可能会想到2种方式

普通青年版

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = []
>>> for i in a:b.append(i+1)
... 
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = b
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

原值修改

a = [1,3,4,6,7,7,8,9,11]

for index,i in enumerate(a):
    a[index] +=1
print(a)

文艺青年

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = map(lambda x:x+1, a)
>>> a
<map object at 0x101d2c630>
>>> for i in a:print(i)
... 
2
3
4
5
6
7
8
9
10
11

还有一种叫做列表生成式

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

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

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

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

建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

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

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

?

1 2 3 4 5 6 7

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

注意，赋值语句：

?

1	a, b = b, a + b

相当于：

?

1 2 3

t = (b, a + b) # t是一个tuple a = t[0] b = t[1]

但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数：

?

1 2 3 4 5 6 7 8 9 10 11 12

>>> fib(10) 1 1 2 3 5 8 13 21 34 55 done

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):
    n,a,b = 0,0,1

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done' 

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回（会把yield后的内容输出后保存断点返回），再次执行时从上次返回的yield语句处继续执行。

data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

>>> g = fib(6) >>> while True: ...     try: ...         x = next(g) ...         print('g:', x) ...     except StopIteration as e: ...         print('Generator return value:', e.value) ...         break ... g: 1 g: 1 g: 2 g: 3 g: 5 g: 8 Generator return value: done

PEP 342 添加了 .throw(...) 和 .close() 方法（前者的作用是让调用方抛出异常，在生成器中处理；后者的作用是终止生成器）

关于如何捕获错误，后面的错误处理还会详细讲解。

还可通过yield实现在单线程的情况下实现并发运算的效果　　

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

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(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

关于yield的别的解析部分：

（1）yield后面可以加多个数值（可以是任意类型），但返回的值是元组类型的。

def get():
    m = 0
    n = 2
    l = ['s',1,3]
    k = {1:1,2:2}
    p = ('2','s','t')
    while True:
        m += 1
        yield m
        yield m ,n ,l ,k ,p
        
it = get()
print(next(it)) #1
print(next(it)) #(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))

print(next(it)) #2
print(type(next(it))) #<class 'tuple'>

如果再加一句:

print(type(next(it))) #<class 'int'>  #返回的是整形

所以返回值的类型，应该是当前调用时，yield 返回值的类型。

（2）关于原函数的return部分return的东西变成了StopIteration异常的值。

在一个 generator function 中，如果没有 return，则默认执行至函数完毕，如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

def fib(max): #10
    n, a, b = 0, 0, 1
    while n < max: #n<10
        #print(b)
        yield b
        a, b = b, a + b
        n = n + 1
    return '---done---'

#f= fib(10)
g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break


g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: ---done---

def gen(max):
    b = 123
    a = 0
    while a < max:
        a += 1
        yield a
        return 'done'
    return 'done---'

g = gen(5)
print(next(g))  # 这里在yield断点那，还没执行return
next(g)  # 返回断点，执行return，抛出异常


1  # next（）的返回值：yield后面跟的参数
Traceback (most recent call last):
  File "H:/python/workspace/day04/generator.py", line 17, in <module>
    next(g)
StopIteration: done   # 异常的值为return 后的值

（3）yield 可以还能够接受参数

send()和next()的区别就在于send可传递参数给yield表达式，这时候传递的参数就会作为yield表达式的值，所以也可以认为next（）等同于send(None)。

send()和next()都有返回值，他们的返回值是当前迭代遇到的yield的时候，yield后面表达式的值，其实就是当前迭代yield后面的参数。

def f(maxx):
    n, a, b = 0, 1, 1
    while n < maxx:
        # print(b)
        y = yield b
        a, b = b, a + b
        n += 1
        print(y)
    return 'error_name'  # 原函数的return变成了迭代完报出错误的值(value)  


fi = f(6)  # 将一个函数变成生成器，并赋值给fi，每次迭代的值都是yield右边的值
print(fi.__next__())  # 运行一次生成器，到yield处中断，运行下面的程序
print(fi.send('Done'))  # 回到第一次运行的生成器的yield中断处，并把Done赋予yield，然后执行下面的程序，到yield再次停止
fi.send('Done')  # 如果这句换成print(fi.send('Done')),则会输出3 
print(fi.send('Done'))  # next和send的返回值都是fi迭代器本次的值

1
Done
2
Done
Done
5

（4）调用一次next是从上次yield到下一次yield结束，并不一定是只走一遍生成器中的循环

def fun(num):
    i = 1
    while i < num:
        if (i % 2):
            yield i
        i += 1


f = fun(15)
print(next(f))
print(next(f))  # 每一次next不定只走一遍fun的循环，这里走了两次
print(f.__next__())

for i in f:  # for循环迭代生成器同理
    print(i)

1
3
5
7
9
11
13

迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

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

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

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

可以使用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()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

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

可以使用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

生成器都是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是永远不可能存储全体自然数的。

通过__iter__/__next__得到一些类（容器）中迭代器的理解

Python的迭代器协议需要 __iter__() 方法返回一个实现了 __next__() 方法的迭代器对象。 如果你只是迭代遍历其他容器的内容，你无须担心底层是怎样实现的。你所要做的只是传递迭代请求既可。

class squares:
    def __init__(self, start, stop):
        self.flag = start - 1
        self.value = self.flag
        self.stop = stop
    def __iter__(self):
        self.value = self.flag
        return self  # 返回一个实现了__next__()方法的迭代器对象
    def __next__(self):
        if self.value == self.stop:
            raise StopIteration
        self.value += 1
        return self.value

a = squares(1,5)
b = squares(1,5)
s = 0
while s<=41:
    for i in a:  # 这里会调用__iter__()然后返回得到一个迭代器对象，然后一直调用__next__()直到报StopIteration后，循环没有结束的话重新调用__iter__()返回迭代器对象，然后next
        s= s + i
        print(s)

1
3
6
10
15  #
16
18
21
25
30  #
31
33
36
40
45

到时迭代器停止工作，实现了三圈循环。

    可以得出：

迭代器走完一轮，抛出异常后，再次调用会先进行__iter__(),再进行__next__()。

class Node:
    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        return iter(self._children)

# Example
if __name__ == '__main__':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    # Outputs Node(1), Node(2)
    for ch in root:  # root会先调用__iter__()然后得到了一个可迭代对象
        print(ch)

这里的 iter() 函数的使用简化了代码， iter(s) 只是简单的通过调用 s.__iter__() 方法来返回对应的迭代器对象， 就跟 len(s) 会调用 s.__len__() 原理是一样的。 

迭代器要注意一点，迭代器只能单次循环

上图可见，for循环只能输出一次，第二次什么也不能输出，因为迭代器是一个单向的容器，走到尾部之后，不会自动再回到开始位置。

生成器不保留前面的数，只能next取下一个，所以遍历一遍完了就没了

关于range和xrange ：

在python2中，有range和xrange之分，range是把数生成列表形式，xrange吧数生成迭代器形式，在python3中，只有range，py3中的range就是py2中的xrange，生成迭代器形式

小结

凡是可作用于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