可迭代(Interable)，迭代器(Iterator),生成器(generator)的手记（11月26日再次修改）

2020年12月26日 0点22分 更新基础信息

Python基础教程:书P158页

实现了方法__iter__的对象是可迭代的，而实现了方法__next__的对象是迭代器。

这两个方法本质上面没有任何的联系。

 

 

今天既然看到这里了，就做个笔记。这个玩意已经花过我很多时间,其实一开始学还好没去纠结它，要不然死的惨兮兮了，网上资料一大堆，反正我是没找到能看懂的，

如果你有机会看到我写的，还是没看懂，请邮件通知我，哪里没看懂，我再写仔细点，至少我觉的，这一块知识，我是可以完全拿下了。

可迭代对象只要有__iter__属性的都可以称呼可迭代(Interable)。

先说明，可迭代对象，上面已经定义了什么是可迭代对象，至少我觉的这句话非常的抽象，简单的来说，就是能被for循环当做对象的，就是可迭代对象。

因为能被for循环，里面一定要有__iter__方法

 

In [119]: import collections.abc                                                                          

In [120]: a = dict()                                                                                      

In [121]: b = list()                                                                                      

In [122]: c = set()                                                                                       

In [123]: d = ''                                                                                          

In [124]: f = range(10)                                                                                   

In [125]: isinstance(a, collections.abc.Iterable)                                                         
Out[125]: True

In [126]: isinstance(b, collections.abc.Iterable)                                                         
Out[126]: True

In [127]: isinstance(c, collections.abc.Iterable)                                                         
Out[127]: True

In [128]: isinstance(d, collections.abc.Iterable)                                                         
Out[128]: True

In [129]: isinstance(f, collections.abc.Iterable)                                                         
Out[129]: True

In [130]: '__iter__' in dir(f)                                                                            
Out[130]: True

In [131]: '__iter__' in dir(d)                                                                            
Out[131]: True

In [132]: '__iter__' in dir(a)                                                                            
Out[132]: True

 通过collections.abc.Iterable（可迭代对象的基类），可以判断出，我上面写的那些对象都是可迭代对象，而且里面都有__iter__方法。

那我现在自己定义一个可迭代对象：

In [137]: class My_Iterable: 
     ...:     def __iter__(self): 
     ...:         print('我是可迭代对象') 
     ...:         pass 
     ...:                                                                                                 

In [138]:                                                                                                 

In [138]: it = My_Iterable()                                                                              

In [139]: isinstance(it, collections.abc.Iterable)                                                        
Out[139]: True

In [140]: for i in it: 
     ...:     print(i) 
     ...:                                                                                                 
我是可迭代对象
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-140-d3d1294ef949> in <module>
----> 1 for i in it:
      2     print(i)
      3 

TypeError: iter() returned non-iterator of type 'NoneType'

In [141]:                              

 从上面的代码里面可以看到，我自己定义了一个可迭代对象，这是一个可迭代对象，也能被for循环调用，但因为我的__iter__返回了不是迭代器，所以报错了。

注意这局提示:TypeError: iter() returned non-iterator of type 'NoneType',但明显我__iter__里面的print输出被执行了。

这些列子可以证明了前面说的只要有__iter__就是可迭代对象，能被for循环调用。

 

这里有一个参考资料，为什么for循环要调用___iter__:https://www.zhihu.com/question/44015086/answer/119281039

 

 

迭代器只要拥有__iter__与__next__属性就是迭代器(Iterator)。

概念又是非常抽象的玩意，这个有点不好用通俗的书，初学者可以简单的认为既能被for循环调用，又能被next函数调用的对象就是迭代器。

Python的内置对象中，基本没有现成的迭代器，当然可以通过iter方法产生迭代器（后面讲），还有一个就是用生成器的生成式。

In [144]: class My_Iterator: 
     ...:     def __iter__(self): 
     ...:         print('我是可迭代对象') 
     ...:         pass 
     ...:     def __next__(self): 
     ...:         pass 
     ...:          
     ...:                                                                                                 

In [145]: my = My_Iterator()                                                                              

In [146]: isinstance(my, collections.abc.Iterator)                                                        
Out[146]: True

 上面定义了一个对简单的迭代器，就因为里面有了两个定义的属性（属性跟方法其实都差不多，可调用的属性就是方法）。

 

我们知道通过iter的函数可以将一个Python中的常见可迭代对象（字典，集合，字符串，元祖，列表等等）变成迭代器，其实这里函数再Python内部定义为

def iter(source, sentinel=None): # known special case of iter
    """
    iter(iterable) -> iterator
    iter(callable, sentinel) -> iterator
    
    Get an iterator from an object.  In the first form, the argument must
    supply its own iterator, or be a sequence.
    In the second form, the callable is called until it returns the sentinel.
    """
    pass

 但具体的操作实在看不出来，根据我的实际来看，对象的__repr__输出肯定改变了，还有多了一些迭代器的方法，少了一些操作对象方法。简单用一个字符串来演示。

In [152]: string = 'sidian'                                                                               

In [153]: o_arr = dir(string)                                                                             

In [154]: string_iter = iter(string)                                                                      

In [155]: n_arr = dir(string_iter)                                                                        

In [156]: string                                                                                          
Out[156]: 'sidian'

In [157]: string_iter                                                                                     
Out[157]: <str_iterator at 0x10b20f390>

In [158]: o_arr                                                                                           
Out[158]: 
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isascii',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

In [159]: set(o_arr)-set(n_arr)                                                                           
Out[159]: 
{'__add__',
 '__contains__',
 '__getitem__',
 '__getnewargs__',
 '__len__',
 '__mod__',
 '__mul__',
 '__rmod__',
 '__rmul__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isascii',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill'}

In [160]: set(n_arr)-set(o_arr)                                                                           
Out[160]: {'__length_hint__', '__next__', '__setstate__'}

 

从上面的操作可以看到，从一个普通字符串（可迭代对象）通过函数iter变成一个迭代器，这里面其实应该执行了很多，同时发现变成了迭代器多一个关键属性__next__

记住一点，迭代器通过iter方法返回的还是他自己，所以一般的自定义迭代器__iter__一般返回自己，但也不是必须的，前面已经说出__iter__只要返回一个迭代器就好。

下面我定义一个编辑畸形的迭代器，通过for循环与next循环产生独立的不同的输出。

In [161]: class Sep_Iterator: 
     ...:     def __iter__(self): 
     ...:         return (i for i in range(5)) 
     ...:     def __next__(self): 
     ...:         return '666' 
     ...:                                                                                                 

In [162]: sep = Sep_Iterator()                                                                            

In [163]: for i in sep: 
     ...:     print(i) 
     ...:                                                                                                 
0
1
2
3
4

In [164]: next(sep)                                                                                       
Out[164]: '666'

In [165]: next(sep)                                                                                       
Out[165]: '666'

In [166]: next(sep)                                                                                       
Out[166]: '666'

 通过上面的执行更加可以看出其实__iter__与__next__是独立的。

在一般的迭代里面__iter__返回(self)自身，因为自身本来就是迭代器，当一个for循环调用该对象时，首相看对象的__iter__方法，返回自身，因为自身本来就时迭代器，符合__iter__的返回标准，然后循环调用对象__next__方法，只到遇到StopIteration停止。这时for循环调用一个迭代器的输出。

 

前面的参考链接链接里面也很具体说了for循环调用迭代器的过程，我的理解简单说下。for循环首先调用对象的__iter__方法，比如一个字符串，它马上生成一个新的字符串的迭代器,然后返回出来，通过迭代器里面的__next__循环取出对象里面的值。这就时为什么，一个Python内置的普通可迭代对象能够重复的被for循环使用，因为for循环在读取他的时候，他的__iter__默认给他搞了一个新的对象出来。

 

可迭代对象与迭代器的区别：

1，迭代器占用的内存特别小。

2，迭代器可以保存内部的状态。

In [168]: x1 = [i for i in range(1000000)]                                                                

In [169]: x2 = (i for i in range(1000000))                                                                

In [170]: x1.__sizeof__()                                                                                 
Out[170]: 8697440

In [171]: x2.__sizeof__()                                                                                 
Out[171]: 96

In [172]: next(x2)                                                                                        
Out[172]: 0

In [173]: next(x2)                                                                                        
Out[173]: 1

In [174]: next(x2)                                                                                        
Out[174]: 2

 

 

 

生成器(generator)，可以用简单生成器(i,for i in range(10)),写法跟列表生成器样式通用，把[]换成()，

还有可以通过自定义方法用yield生成。

生成器肯定是迭代器，更加是可迭代对象，生成器的功能是最多的

生成器是一种特殊的迭代器，特殊在哪里，就是这个特殊迭代器在制作的时候不需要自己定义__iter__与__next__

想判断某个对象迭代器还是容器，可以拿该对象为参数，分别调用iter，如果返回的对象相同就时迭代器，容器对象每次返回的都是不同的对象

而且相对迭代器有三个生成器对象的专属方法：

• send
• throw
• close

简单的来说，迭代器只能从对象里面取值，生成器可以互动了，你还可以向对象里面送值。

yield，send,throw,close。我这里不写了，篇幅很长。

可以参考：https://blog.csdn.net/jpch89/article/details/87036970

一般用的最多也就yield及send,携程的时候要用。

---