好程序员Python 培训分享 Python 生成器与迭代器 ， Python 生成器与迭代器对于喜欢 Python 开发的小伙伴们来说应该是不陌生的，不了解的小伙伴也没有关系，本篇文章 小编就给小伙伴们详解一下 Python 生成器与迭代器，感兴趣的小伙伴就随小编来了解一下吧。

列表生成式:

例一：

a = [i+1 for i in range(10)]

print(a)

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

例二：

L = [1, 2, 3, 4, 5]

print([i*i for i in L if i>3])

输出:

[16, 25]

例三：

L = [1, 2, 3, 4, 5]

I = [6, 7, 8, 9, 10]

print([i*a for i in L for a in I if i > 2 if a < 8])

输出：

[18, 21, 24, 28, 30, 35]

生成器：

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

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

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

示例：

L = [1, 2, 3, 4, 5]

I = [6, 7, 8, 9, 10]

g = (i*a for i in L for a in I )

print(g)

输出：

<generator object <genexpr> at 0x00000276586C1F48>

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

我们可以直接打印出list 的每一个元素，可以通过 generator 的 next() 方法

next(g)

例一：

L = [1, 2, 3, 4, 5]

I = [6, 7, 8, 9, 10]

g = (i*a for i in L for a in I )

print(next(g))

print(next(g))

print(next(g))

输出：

6

7

8

例二：

L = [1, 2, 3, 4, 5]

I = [6, 7, 8, 9, 10]

g = (i*a for i in L for a in I if i > 2 if a < 8)

print(next(g))

print(next(g))

print(next(g))

输出：

18

21

24

因为generator 保存的是算法，每次调用 next(g) 就计算出 g 的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出 StopIteration 的错误。正确的方法是使用 for 循环，因为 generator 也是可迭代对象：

例三：

g = (i*i for i in range(0, 5))

for i in g:

    print(i)

当我们创建了一个generator 后，基本上永远不会调用 next() 方法，而是通过 for 循环来迭代它。

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

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

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

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

def fib(max):

    n, a, b = 0, 0, 1

    while n < max:

        print b

        a, b = b, a + b

        n = n + 1

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

>>> fib(6)

1

1

2

3

5

8

仔细观察，可以看出，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 ：

def fib(max):

    n, a, b = 0, 0, 1

    while n < max:

        yield b

        a, b = b, a + b

        n = n + 1

    return 'done'

print(fib(5))

输出：

<generator object fib at 0x0000023DC66C1F48>

调用方法：   ## 但是用 for 循环调用 generator 时， \

            ## 发现拿不到 generator 的 return 语句 \

            ## 的返回值。如果想要拿到返回值，必须捕获 StopIteration 错误，返回值包含在 StopIteration 的 value 中：

for i in fib(5):

    print(i)

输出：

1

1

2

3

5

或者：

date = fib(5)

print(date.__next__())

print(date.__next__())

print(date.__next__())

print('test')

print(date.__next__())

print(date.__next__())

输出：

1

1

2

test

3

5

send 方法有一个参数，该参数指定的是上一次被挂起的 yield 语句的返回值

还可通过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")

通过生成器实现协程并行运算

迭代器:

可以直接作用于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 是永远不可能存储全体自然数的。

小结:

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

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

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

Python3 的 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