pytho 迭代器与生成器

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

实例(Python 3.0+)

>>>list=[1,2,3,4]>>>it = iter(list)# 创建迭代器对象>>> print (next(it))# 输出迭代器的下一个元素1>>>print (next(it))2>>>

迭代器对象可以使用常规for语句进行遍历：

实例(Python 3.0+)

#!/usr/bin/python3list=[1,2,3,4]it = iter(list)# 创建迭代器对象forx init: print(x,end="")

执行以上程序，输出结果如下：

1 2 3 4

也可以使用 next() 函数：

实例(Python 3.0+)

#!/usr/bin/python3import sys# 引入 sys 模块 list=[1,2,3,4]it = iter(list)# 创建迭代器对象 whileTrue: try:print (next(it))except StopIteration:sys.exit()

执行以上程序，输出结果如下：

1234

---

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。

以下实例使用 yield 实现斐波那契数列：

实例(Python 3.0+)

#!/usr/bin/python3import sysdef fibonacci(n):# 生成器函数 - 斐波那契 a, b,counter = 0, 1,0 whileTrue: if(counter >n):return yielda a,b = b,a + bcounter += 1f =fibonacci(10)# f 是一个迭代器，由生成器返回生成 while True:try: print(next(f),end="")except StopIteration:sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

Python3 循环语句

Python3 函数

笔记列表

1. #2

      cowpea

     115***[e-mail]

   来看一下有yield和没有yield的情况会对生成器了解多点：

   第一种：使用 yield

   #!/usr/bin/python3import sysdef fibonacci(n,w=0): # 生成器函数 - 斐波那契    a, b, counter = 0, 1, 0    while True:        if (counter > n):             return        yield a        a, b = b, a + b        print('%d,%d' % (a,b))        counter += 1f = fibonacci(10,0) # f 是一个迭代器，由生成器返回生成while True:    try:        print (next(f), end=" ")    except :        sys.exit()

   输出结果：

   0 1,11 1,21 2,32 3,53 5,85 8,138 13,2113 21,3421 34,5534 55,8955 89,144

   第二种：不使用 yield

   #!/usr/bin/python3import sysdef fibonacci(n,w=0): # 生成器函数 - 斐波那契    a, b, counter = 0, 1, 0    while True:        if (counter > n):             return        #yield a        a, b = b, a + b        print('%d,%d' % (a,b))        counter += 1f = fibonacci(10,0) # f 是一个迭代器，由生成器返回生成while True:    try:        print (next(f), end=" ")    except :        sys.exit()

   输出结果：

   1,11,22,33,55,88,1313,2121,3434,5555,8989,144

   第二种没有yield时，函数只是简单执行，没有返回迭代器f。这里的迭代器可以用生成l列表来理解一下：

   >>> l = [i for i in range(0,15)]>>> print(l)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]>>> m = (i for i in range(0,15))>>> print(m)<generator object <genexpr> at 0x104b6f258>>>> for g in m:...     print(g,end=', ')... 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

   这里的m就像上面的f一样，是迭代器。

   cowpea

      cowpea

     115***[e-mail]

   2个月前 (07-27)
2. #1

      ErikaEmma

     463***[e-mail]

     参考地址

   什么情况下需要使用 yield？

   一个函数 f，f 返回一个 list，这个 list 是动态计算出来的（不管是数学上的计算还是逻辑上的读取格式化），并且这个 list 会很大（无论是固定很大还是随着输入参数的增大而增大），这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个 list 元素而不是直接得到一个完整的 list 来节省内存，这个时候 yield 就很有用。

   具体怎么使用 yield 参考：Python yield 使用浅析

   以斐波那契函数为例，我们一般希望从 n 返回一个 n 个数的 list：

   def fab(max):    n, a, b = 0, 0, 1    L = []    while n < max:        L.append(b)        a, b = b, a + b        n = n + 1    return L

   上面那个 fab 函数从参数 max 返回一个有 max 个元素的 list，当这个 max 很大的时候，会非常的占用内存。

   一般我们使用的时候都是这个样子的，比如：

   f = fab(1000)while True:    try:        print (next(f), end=" ")    except StopIteration:        sys.exit()

   这样我们实际上是先生成了一个 1000 个元素的 list:f，然后我们再去使用这个 f。

   现在，我们换一个方法：

   因为我们实际使用的是 list 的遍历，也就是 list 的迭代器。那么我们可以让这个函数 fab 每次只返回一个迭代器——一个计算结果，而不是一个完整的 list：

   def fab(max):     n, a, b = 0, 0, 1     while n < max:         yield b         # print b         a, b = b, a + b         n = n + 1 

   这样，我们每次调用fab函数，比如这样：

   for x in fab(1000):    print(x)

   或者 next 函数之类的，实际上的运行方式是每次的调用都在 yield 处中断并返回一个结果，然后再次调用的时候再恢复中断继续运行。

3. 迭代器

         迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。

   1.1 使用迭代器的优点

         对于原生支持随机访问的数据结构（如tuple、list），迭代器和经典for循环的索引访问相比并无优势，反而丢失了索引值（可以使用内建函数enumerate()找回这个索引值）。但对于无法随机访问的数据结构（比如set）而言，迭代器是唯一的访问元素的方式。

         另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等。

         迭代器更大的功劳是提供了一个统一的访问集合的接口，只要定义了__iter__()方法对象，就可以使用迭代器访问。

   迭代器有两个基本的方法

   • next方法：返回迭代器的下一个元素
   • __iter__方法：返回迭代器对象本身

   下面用生成斐波那契数列为例子，说明为何用迭代器

   代码1

   

    def fab(max):     n, a, b = 0, 0, 1     while n < max:         print b         a, b = b, a + b         n = n + 1

   

   直接在函数fab(max)中用print打印会导致函数的可复用性变差，因为fab返回None。其他函数无法获得fab函数返回的数列。

   代码2

   

    def fab(max):     L = []    n, a, b = 0, 0, 1     while n < max:         L.append(b)         a, b = b, a + b         n = n + 1    return L

   

   代码2满足了可复用性的需求，但是占用了内存空间，最好不要。

   代码3

   对比

    for i in range(1000): pass

    for i in xrange(1000): pass

   前一个返回1000个元素的列表，而后一个在每次迭代中返回一个元素，因此可以使用迭代器来解决复用可占空间的问题

   

    class Fab(object):     def __init__(self, max):         self.max = max         self.n, self.a, self.b = 0, 0, 1     def __iter__(self):         return self     def next(self):         if self.n < self.max:             r = self.b             self.a, self.b = self.b, self.a + self.b             self.n = self.n + 1             return r         raise StopIteration()

   

   执行

   ?

   1

   2

   3

   4

   5

   6

   7

   8

   9

   >>> for key in Fabs(5):

       printkey

    

        

   1

   1

   2

   3

   5

   Fabs 类通过 next() 不断返回数列的下一个数，内存占用始终为常数　　

   1.2 使用迭代器

   使用内建的工厂函数iter(iterable)可以获取迭代器对象：

   ?

   1

   2

   3

   4

   >>> lst = range(5)

   >>> it = iter(lst)

   >>> it

   <listiterator object at0x01A63110>

   使用next()方法可以访问下一个元素：

   ?

   1

   2

   3

   4

   5

   6

   >>> it.next()

   0

   >>> it.next()

   1

   >>> it.next()

   2

   python处理迭代器越界是抛出StopIteration异常

   ?

   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   >>> it.next()

   3

   >>> it.next

   <method-wrapper 'next' of listiterator object at0x01A63110>

   >>> it.next()

   4

   >>> it.next()

    

   Traceback (most recent call last):

     File"<pyshell#27>", line1, in <module>

       it.next()

   StopIteration

   了解了StopIteration，可以使用迭代器进行遍历了

   

   lst = range(5)it = iter(lst)try:    while True:        val = it.next()        print valexcept StopIteration:    pass

   

   结果

   ?

   1

   2

   3

   4

   5

   6

   >>>

   0

   1

   2

   3

   4

   事实上，因为迭代器如此普遍，python专门为for关键字做了迭代器的语法糖。在for循环中，Python将自动调用工厂函数iter()获得迭代器，自动调用next()获取元素，还完成了检查StopIteration异常的工作。如下

   

   >>> a = (1, 2, 3, 4)>>> for key in a:    print key    1234

   

   首先python对关键字in后的对象调用iter函数迭代器，然后调用迭代器的next方法获得元素，直到抛出StopIteration异常。

   1.3 定义迭代器

   下面一个例子——斐波那契数列

   

   # -*- coding: cp936 -*-class Fabs(object):    def __init__(self,max):        self.max = max        self.n, self.a, self.b = 0, 0, 1  #特别指出：第0项是0，第1项是第一个1.整个数列从1开始    def __iter__(self):        return self    def next(self):        if self.n < self.max:            r = self.b            self.a, self.b = self.b, self.a + self.b            self.n = self.n + 1            return r        raise StopIteration()print Fabs(5)for key in Fabs(5):    print key    

   

   结果

   ?

   1

   2

   3

   4

   5

   6

   <__main__.Fabs object at0x01A63090>

   1

   1

   2

   3

   5

    

   回到顶部

   2. 生成器

         带有 yield 的函数在 Python 中被称之为 generator（生成器），几个例子说明下（还是用生成斐波那契数列说明）

   可以看出代码3远没有代码1简洁，生成器（yield）既可以保持代码1的简洁性，又可以保持代码3的效果

   代码4　

   

   def fab(max):    n, a, b = 0, 0, 1    while n < max:        yield b        a, b = b, a + b        n = n + 1

   

   执行

   ?

   1

   2

   3

   4

   5

   6

   7

   8

   9

   >>> for n in fab(5):

       printn

    

        

   1

   1

   2

   3

   5

         简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

   也可以手动调用 fab(5) 的 next() 方法（因为 fab(5) 是一个 generator 对象，该对象具有 next() 方法），这样我们就可以更清楚地看到 fab 的执行流程：

   ?

   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   >>> f = fab(3)

   >>> f.next()

   1

   >>> f.next()

   1

   >>> f.next()

   2

   >>> f.next()

    

   Traceback (most recent call last):

     File"<pyshell#62>", line1, in <module>

       f.next()

   StopIteration

   return作用

   在一个生成器中，如果没有return，则默认执行到函数完毕；如果遇到return,如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。例如

   ?

   1

   2

   3

   4

   5

   6

   7

   8

   9

   >>> s = fab(5)

   >>> s.next()

   1

   >>> s.next()

    

   Traceback (most recent call last):

     File"<pyshell#66>", line1, in <module>

       s.next()

   StopIteration

   代码5  文件读取

   

    def read_file(fpath):     BLOCK_SIZE = 1024     with open(fpath, 'rb') as f:         while True:             block = f.read(BLOCK_SIZE)             if block:                 yield block             else:                 return