Python 迭代器深入理解与应用示例

迈不过友情╰ 2022-05-25 04:22 165阅读 0赞

本篇文章简单谈谈可迭代对象，迭代器和生成器之间的关系。

# 三者简要关系图 #

![Center][]

# 可迭代对象与迭代器 #

刚开始我认为这两者是等同的，但后来发现并不是这样；下面直接抛出结论：

1）可迭代对象包含迭代器。  
2）如果一个对象拥有\_\_iter\_\_方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。  
3）定义可迭代对象，必须实现\_\_iter\_\_方法；定义迭代器，必须实现\_\_iter\_\_和next方法。

你也许会问，结论3与结论2是不是有一点矛盾？既然一个对象拥有了next方法就是迭代器，那为什么迭代器必须同时实现两方法呢？

因为结论1，迭代器也是可迭代对象，因此迭代器必须也实现\_\_iter\_\_方法。

介绍一下上面涉及到的两个方法：

1）\_\_iter\_\_()

该方法返回的是当前对象的迭代器类的实例。因为可迭代对象与迭代器都要实现这个方法，因此有以下两种写法。

写法一：用于可迭代对象类的写法，返回该可迭代对象的迭代器类的实例。

写法二：用于迭代器类的写法，直接返回self（即自己本身），表示自身即是自己的迭代器。

也许有点晕，没关系，下面会给出两写法的例子，我们结合具体例子看。

2）next()

返回迭代的每一步，实现该方法时注意要最后超出边界要抛出StopIteration异常。

下面举个可迭代对象与迭代器的例子：

\[python\]  [view plain][]   [copy][view plain]

1.  \#!/usr/bin/env python  
2.  \# coding=utf-8  
3.    
4.    
5.  **class** MyList(object):            \# 定义可迭代对象类  
6.    
7.      **def** \_\_init\_\_(self, num):  
8.          self.data = num          \# 上边界  
9.    
10.     **def** \_\_iter\_\_(self):  
11.         **return** MyListIterator(self.data)  \# 返回该可迭代对象的迭代器类的实例  
12.   
13.   
14. **class** MyListIterator(object):    \# 定义迭代器类，其是MyList可迭代对象的迭代器类  
15.   
16.     **def** \_\_init\_\_(self, data):  
17.         self.data = data         \# 上边界  
18.         self.now = 0             \# 当前迭代值，初始为0  
19.   
20.     **def** \_\_iter\_\_(self):  
21.         **return** self              \# 返回该对象的迭代器类的实例；因为自己就是迭代器，所以返回self  
22.   
23.     **def** next(self):              \# 迭代器类必须实现的方法  
24.         **while** self.now < self.data:  
25.             self.now += 1  
26.             **return** self.now - 1  \# 返回当前迭代值  
27.         **raise** StopIteration      \# 超出上边界，抛出异常  
28.   
29.   
30. my\_list = MyList(5)              \# 得到一个可迭代对象  
31. **print** type(my\_list)              \# 返回该对象的类型  
32.   
33. my\_list\_iter = iter(my\_list)     \# 得到该对象的迭代器实例，iter函数在下面会详细解释  
34. **print** type(my\_list\_iter)  
35.   
36.   
37. **for** i **in** my\_list:                \# 迭代  
38.     **print** i

运行结果：

![Center 1][]

问题：上面的例子中出现了iter函数，这是什么东西？和\_\_iter\_\_方法有关系吗？  
其实该函数与迭代是息息相关的，通过在Python命令行中打印“help(iter)”得知其有以下两种用法。  
  
用法一：iter(callable, sentinel)  
不停的调用callable，直至其的返回值等于sentinel。其中的callable可以是函数，方法或实现了\_\_call\_\_方法的实例。  
  
用法二：iter(collection)  
1）用于返回collection对象的迭代器实例，这里的collection我认为表示的是可迭代对象，即该对象必须实现\_\_iter\_\_方法； 事实上iter函数与\_\_iter\_\_方法联系非常紧密，iter()是直接调用该对象的\_\_iter\_\_()，并把\_\_iter\_\_()的返回结果作为自己的返回值，故该用法常被称为“创建迭代器”。  
2）iter函数可以显示调用，或当执行“for i in obj:”，Python解释器会在第一次迭代时自动调用iter(obj)，之后的迭代会调用迭代器的next方法，for语句会自动处理最后抛出的StopIteration异常。

通过上面的例子，相信对可迭代对象与迭代器有了更具体的认识，那么生成器与它们有什么关系呢？下面简单谈一谈

# 生成器 #

生成器是一种特殊的迭代器，生成器自动实现了“迭代器协议”（即\_\_iter\_\_和next方法），不需要再手动实现两方法。

生成器在迭代的过程中可以改变当前迭代值，而修改普通迭代器的当前迭代值往往会发生异常，影响程序的执行。

看一个生成器的例子：

\[python\]  [view plain][]   [copy][view plain]

1.  \#!/usr/bin/env python  
2.  \# coding=utf-8  
3.    
4.    
5.  **def** myList(num):      \# 定义生成器  
6.      now = 0           \# 当前迭代值，初始为0  
7.      **while** now < num:  
8.          val = (**yield** now)                      \# 返回当前迭代值，并接受可能的send发送值；yield在下面会解释  
9.          now = now + 1 **if** val **is** None **else** val  \# val为None，迭代值自增1，否则重新设定当前迭代值为val  
10.   
11. my\_list = myList(5)   \# 得到一个生成器对象  
12.   
13. **print** my\_list.next()  \# 返回当前迭代值  
14. **print** my\_list.next()  
15.   
16. my\_list.send(3)       \# 重新设定当前的迭代值  
17. **print** my\_list.next()  
18.   
19. **print** dir(my\_list)    \# 返回该对象所拥有的方法名，可以看到\_\_iter\_\_与next在其中

运行结果：

![Center 2][]

具有yield关键字的函数都是生成器 ，yield可以理解为return，返回后面的值给调用者。不同的是return返回后，函数会释放，而生成器则不会。在直接调用next方法或用for语句进行下一次迭代时，生成器会从yield下一句开始执行，直至遇到下一个yield。

\#生成器函数，函数里只要有yield关键字

def gen\_func():  
    yield 1  
    yield 2  
    yield 3  
  
  
def fib(index):  
    if index <= 2:  
        return 1  
    else:  
        return fib(index-1) + fib(index-2)  
  
  
def fib2(index):  
    re\_list = \[\]  
    n,a,b = 0,0,1  
    while n<index:  
        re\_list.append(b)  
        a,b = b, a+b  
        n += 1  
    return re\_list  
  
  
def gen\_fib(index):  
    n,a,b = 0,0,1  
    while n<index:  
        yield b  
        a,b = b, a+b  
        n += 1  
  
  
for data in gen\_fib(10):  
    print (data)  
\# print (gen\_fib(10))  
\# 斐波拉契 0 1 1 2 3 5 8  
\#惰性求值， 延迟求值提供了可能  
  
  
def func():  
    return 1  
  
  
if \_\_name\_\_ == "\_\_main\_\_":  
    \#生成器对象， python编译字节码的时候就产生了，  
    gen = gen\_func()  
    for value in gen:  
        print (value)  
    \# re = func()  
    \# pass

[Center]: /images/20220525/04b31a244183488c81e6aedf23c59852.png
[view plain]: https://blog.csdn.net/jinixin/article/details/72232604#
[Center 1]: /images/20220525/97cbb5d6de8f4b418d477dc67240df11.png
[Center 2]: /images/20220525/58be09c7d3a64237b0fe4b1dd1c2130f.png