python 可迭代对象、迭代器与生成器小结-CSDN博客

本文链接：https://blog.csdn.net/qq_42206477/article/details/84582701

这两天刚好学习了这一块的知识，就借机会整理下这三个概念的关系啦。
废话不多说，开始吧！

关于可迭代对象的理解

说迭代器之前，必须要说可迭代对象。
什么是可迭代对象？
顾名思义，就是一个对象能够被迭代的使用。
我们可以利用Python提供的模块collections来判断对象是否是可迭代对象。

from collections import Iterable

a = open('input.txt')
b = 1
c = 'yin银鱼'
d = {'name':"yin银鱼"}
e = (1,2,3,4)
f = {1,2,3,4}
g = [1,2,3,4]

print(isinstance(a, Iterable))  # True
print(isinstance(b, Iterable))  # False
print(isinstance(c, Iterable))  # True
print(isinstance(d, Iterable))  # True
print(isinstance(e, Iterable))  # True
print(isinstance(f, Iterable))  # True
print(isinstance(g, Iterable))  # True

可以发现，文件对象、字符串、字典、元组、集合、列表都是可迭代对象。
其实，判断一个对象是否可迭代，关键看这个对象是否有__iter__()方法。

a = open('input.txt')
b = 1
c = 'yin银鱼'
d = {'name':"yin银鱼"}
e = (1,2,3,4)
f = {1,2,3,4}
g = [1,2,3,4]

print(hasattr(a, "__iter__"))  # True
print(hasattr(b, "__iter__"))  # False
print(hasattr(c, "__iter__"))  # True
print(hasattr(d, "__iter__"))  # True
print(hasattr(e, "__iter__"))  # True
print(hasattr(f, "__iter__"))  # True
print(hasattr(g, "__iter__"))  # True

由此，可以得出结论：
凡是有__iter__()方法的对象都是可迭代对象（Iterable）

关于迭代器的理解

可迭代对象说完了，就可以说迭代器了。
说迭代器之前，我们还是再说说容器与可迭代对象：
在python中，属于容器类型有:list,dict,set,str,tuple…。容器仅仅只是用来存放数据的，它并不具备从容器中取出元素的功能，事实上，是可迭代对象赋予了容器这种取出元素的能力。（此处参考博文）

说了这么多，那么什么是迭代器呢？
廖大大给出的解释：可以被next()调用并不断返回下一个值的对象叫迭代器Iterator。
廖大大总结得很到位（抱紧大腿），迭代器与可迭代对象区别在于__next__()方法。
用代码验证一下：

from collections.abc import Iterator

a = open('input.txt')
b = 1
c = 'yin银鱼'
d = {'name':"yin银鱼"}
e = (1,2,3,4)
f = {1,2,3,4}
g = [1,2,3,4]

print(isinstance(a, Iterator))  # True
print(isinstance(b, Iterator))  # False
print(isinstance(c, Iterator))  # False
print(isinstance(d, Iterator))  # False
print(isinstance(e, Iterator))  # False
print(isinstance(f, Iterator))  # False
print(isinstance(g, Iterator))  # False

print(hasattr(a, "__next__"))  # True
print(hasattr(b, "__next__"))  # False
print(hasattr(c, "__next__"))  # False
print(hasattr(d, "__next__"))  # False
print(hasattr(e, "__next__"))  # False
print(hasattr(f, "__next__"))  # False
print(hasattr(g, "__next__"))  # False

可以看出，只有文件类型的对象是迭代器。

为了更深入的理解迭代器，我们引入for循环内部机制。
我们前面分析过，可迭代对象是不可以直接从中取得元素，那for循环是如何取得可迭代对象中的元素呢？

my_list = [1,2,3,4,5]
for i in my_list:
    print(i)
    
========输出结果========
1
2
3
4
5

其实在for循环内部，首先my_list会调用__iter__()方法，将列表my_list变为一个迭代器，然后这个迭代器再调用其__next__()方法，最后依次打印各个元素。

注意：可迭代对象转化为迭代器，可使用iter()方法。一旦使用iter()方法，就会调用可迭代对象内部的__iter__()方法，返回一个迭代器对象。

my_list = ["s","w","q"]
print(isinstance(my_list, Iterator)) #False
my_iter = iter(my_list) #将可迭代对象转化为迭代器
print(isinstance(my_iter, Iterator)) #True
print(hasattr(my_iter, '__next__'))  #True

#被next()调用，并不断返回下一个值
print(next(my_iter))   # s
print(next(my_iter))   # w
print(next(my_iter))   # q

由此，我们就验证了：
迭代器Iterator就是可以被next()调用并不断返回下一个值的对象。

关于生成器的理解

在python中，一边循环一边计算的机制，称为生成器：generator

要创建一个generator，有很多种方法，这里我们介绍其中的两种方法：
第一种，方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator。

g = (x * x for x in range(10))
print(type(g)) #<class 'generator'>

print(next(g)) # 0
print(next(g)) # 1
print(next(g)) # 4

第二种，一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

my_odd = odd()
print(next(my_odd))
print(next(my_odd))
print(next(my_odd))

=============输出结果=============
step 1
1
step 2
3
step 3
5

注意：函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

那么，生成器与迭代器有什么关系呢？
其实，生成器就是一种特殊的迭代器。不信的话，我们验证一下。

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

my_odd = odd()
g = (x * x for x in range(10))

print(hasattr(my_odd, "__next__"))  # True
print(isinstance(my_odd, Iterator))  # True

print(hasattr(g, "__next__"))  # True
print(isinstance(g, Iterator))  # True