python可迭代对象、迭代器、生成器 python学习之可迭代对象、迭代器、生成器

#分别对python的各种数据类型进行判断
from collections import Iterable
a = 123
isinstance(a,Iterable) >>> False
a = 'abc'
isinstance(a,Iterable) >>> True
a = (1,2,3)
isinstance(a,Iterable) >>> True
a = [1,2,3]
isinstance(a,Iterable) >>> True
a = {'name':'wwl','age':24,'sex':'男'}
isinstance(a,Iterable) >>> True
a = {1,2,3}
isinstance(a,Iterable) >>> True
#可以看到字符串，元组，列表，字典，集合是可迭代对象；数字不是

dir(int)
['...（省略）', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__','...（省略）' ]
dir(str)
['...（省略）', '__iter__', '...（省略）']
dir(tuple)
['...（省略）', '__iter__', '...（省略）']
dir(list)
['...（省略）', '__iter__', '...（省略）']
dir(dict)
['...（省略）', '__iter__', '...（省略）']
dir(set)
['...（省略）', '__iter__', '...（省略）']

#自定义两个类:A类和B类，其中B类实现__iter__方法，A类则没有
from collections import Iterable
class A():
... def __init__(self):
... pass
... 
class B():
 def __init__(self):
 pass
 def __iter__(self):
 return self
#生成两个实例化对象:a和b 
a = A()
b = B()
#可以看到实现__iter__方法的b对象是可迭代对象，而a对象不是
isinstance(a,Iterable) >>> False
isinstance(b,Iterable) >>> True

#自定义一个实现__getitem__方法的序列
class A():
 def __init__(self,*args):
 self.args = args 
 def __getitem__(self,i): 
 return self.args[i]
 def __len__(self):
 num = 0
 while True:
 try:
 self.args[num]
 num += 1
 except:
 return num
 
a = A(1,2,3,'ss','dd')
#可以看到实例化后的对象是可以通过for...in进行循环访问的，表示其是可迭代对象。
for i in range(len(a)):
 print(a[i]) >>> 1 2 3 ss dd 
#我们使用collections模块的Iterable进行判断：
from collections import Iterable,Iterator
isinstance(a,Iterable) >>> False
#结果出乎意料，判定对象a不是可迭代对象，为什么呢？
#因为collections模块的Iterable自动忽略了对象的__getitem__方法，只根据对象是否有__iter__方法进行判断。一般来说，标准的序列均实现了__iter__方法。
#既然上面方法无法判断具有__getitem__方法的序列是否是可迭代对象，那又该如何判断呢？
#可以使用iter()函数，如果不报错，说明是可迭代对象，报错就不是
b = iter(a)
isinstance(b,Iterable) >>> True
isinstance(b,Iterator) >>> True

from collections import Iterable,Iterator
#创建两个类:B类和C类，B类实现了__iter__方法，C类实现了__iter__和__next__方法
class B():
 def __init__(self):
 pass
 def __iter__(self):
 return self
 
class C():
 def __init__(self):
 pass
 def __iter__(self):
 return self
 def __next__(self):
 return 123
#实例化两个对象 
b = B()
c = C()
#可以看到b对象是可迭代对象，却不是迭代器;c对象既是可迭代对象，又是迭代器.
isinstance(b,Iterable) >>> True
isinstance(b,Iterator) >>> False
isinstance(c,Iterator) >>> True
isinstance(c,Iterable) >>> True

#自定义两个类，一个支持__iter__()方法，一个支持__getitem__()方法
#1.定义一个支持迭代协议的集合对象：
class A():
 def __init__(self):
 pass
 def __iter__(self):
 self.num = 0
 return self
 def __next__(self):
 if self.num < 10:
 N = self.num
 self.num += 1
 return N
 else:
 raise StopIteration
 
a = A()
b = iter(a)
from collections import Iterable,Iterator
#由于A类中我们定义的__iter__()函数是返回自己，同时定义了自身的__next__()方法,所以对象a既是可迭代对象，又是迭代器。
isinstance(a,Iterable) >>> True
isinstance(a,Iterator) >>> True
#同时我们可以看到对象a经过iter()方法后生成的b对象是迭代器。
isinstance(b,Iterator) >>> True
isinstance(b,Iterable) >>> True

#定义一个支持序列协议的对象
class B():
 def __init__(self,*args):
 self.args = args 
 def __getitem__(self,i): 
 return self.args[i]
 def __len__(self):
 num = 0
 while True:
 try:
 self.args[num]
 num += 1
 except:
 return num

b = B()
c = iter(b)

#由于b对象定义的是__getitem__()方法，所以无法使用collections模块对b对象进行判断。
#这里我们只对使用了iter()方法后生成的c对象进行判断
isinstance(c,Iterable) >>> True
isinstance(c,Iterator) >>> True
#可以看到使用了iter()方法后生成的对象c是迭代器

class A():
 def __init__(self):
 self.num = 1
 def __call__(self):
 x = self.num
 self.num += 1
 return x 
 
a = A()
b = iter(a,5)
from collections import Iterable,Iterator
#我们可以看到a对象既不是可迭代对象也不是迭代器，但通过iter()方法返回的对象b确实迭代器
isinstance(a,Iterable) >>> False
isinstance(a,Iterator) >>> False
isinstance(b,Iterator) >>> True
isinstance(b,Iterable) >>> True
#通过for...in循环遍历打印（每次循环都调用__call__()方法，直至返回值等于5，触发StopIteration停止迭代）
for i in b:
 print(i) >>> 1 2 3 4
 
#iter（）的第二种形式的一个有用的应用是构建块读取器。例如，从二进制数据库文件中读取固定宽度的块，直到到达文件结尾：
from functools import partial
with open('mydata.db', 'rb') as f:
 for block in iter(partial(f.read, 64), b''):
 process_block(block)

#定义__iter__()方法，可以返回自己，但自己要定义__next__()方法；也可以返回其他对象的迭代器
#第一种：返回自身，同时定义自身的__next__()方法
class A():
 def __init__(self):
 pass
 def __iter__(self):
 self.num = 0
 return self
 def __next__(self):
 if self.num < 10:
 N = self.num
 self.num += 1
 return N
 else:
 raise StopIteration
a = A()
b = a.__iter__()
from collections import Iterable,Iterator
#由于A类中我们定义的__iter__()函数是返回自己，同时定义了自身的__next__()方法,所以对象a既是可迭代对象，又是迭代器。
isinstance(a,Iterable) >>> True
isinstance(a,Iterator) >>> True
#同时我们可以看到对象a经过iter()方法后生成的b对象是迭代器。
isinstance(b,Iterable) >>> True
isinstance(b,Iterator) >>> True

#第二种：返回其他对象的迭代器
class A():
 def __init__(self):
 pass
 def __iter__(self):
 self.num = 0
 return b

class B(A):
 def __next__(self):
 if self.num < 10:
 N = self.num
 self.num += 1
 return N
 else:
 raise StopIteration
 
#实例化两个对象：a和b,当调用对象a的__iter__()方法时，返回对象b，B继承于A类,所以b对象是一个迭代器。
a = A()
b = B()
#调用a的__iter__()方法
c = a.__iter__()
from collections import Iterable,Iterator
#由于对象a不具备__next__()方法，因此仅仅是一个可迭代对象
isinstance(a,Iterable) >>> True
isinstance(a,Iterator) >>> False
#但是调用对象a的__iter()方法生成的c，同时具备__iter__()和__next__()方法，是一个迭代器。
isinstance(c,Iterable) >>> True
isinstance(c,Iterator) >>> True

#iter()函数：其运行机制是寻找对象中的__iter__()方法，运行并返回结果，如果__iter__()方法返回的不是迭代器，则此方法会报错；如果没有此方法，则寻找__getitem__()方法。
class A():
 def __init__(self):
 pass
 def __iter__(self):
 return 1 #我们知道数字1不是迭代器，此函数返回的是一个非迭代器 
a = A()
b = iter(a)
Traceback (most recent call last):
 File "<input>", line 10, in <module>
TypeError: iter() returned non-iterator of type 'int'

#直接调用__iter__()方法：如果想通过调用此方法生成迭代器，只能定义在此函数下返回一个迭代器；如果定义返回的不是迭代器，调用此方法是不会生成迭代器的。
class A():
 def __init__(self):
 pass
 def __iter__(self):
 return 1 
a = A()
#直接调用__iter__()方法
b = a.__iter__()
#我们可以看到返回的是1，而不是迭代器，只有当你定义返回迭代器时，调用此方法才会返回迭代器
print(b) >>> 1

#我们定义一个类：具有__iter__()方法，但返回的不是迭代器
class A():
 def __init__(self):
 pass
 def __iter__(self):
 return 1 
a = A()
from collections import Iterable
#我们使用isinstance()结合collections看一下：会发现此方法认为他是一个可迭代对象
isinstance(a,Iterable) >>> True
#我们使用for...in进行循环访问，发现并不能
for i in a:
 print(i) 
Traceback (most recent call last):
 File "<input>", line 1, in <module>
TypeError: iter() returned non-iterator of type 'int'
#接下来，我们再定义一个类：具有__iter__()方法和__next__()方法，但返回的不是迭代器
class A():
 def __init__(self):
 pass
 def __iter__(self):
 pass
 def __next__(self):
 pass

a = A()
from collections import Iterator
#我们使用isinstance()结合collections看一下：会发现此方法认为他是一个迭代器
isinstance(a,Iterator) >>> True
#我们使用for...in进行循环访问，发现并不能
for i in a:
 print(a) 
Traceback (most recent call last):
 File "<input>", line 1, in <module>
TypeError: iter() returned non-iterator of type 'NoneType'

class A():
 def __init__(self):
 pass
 def __iter__(self):
 return 1 
a = A()
#使用iter()函数如果报错，则不是可迭代对象，如果不报错，则是可迭代对象
b = iter(a)
Traceback (most recent call last):
 File "<input>", line 1, in <module>
TypeError: iter() returned non-iterator of type 'int'

#for...in循环的实质是：先调用对象的__iter__()方法，返回一个迭代器，然后不断的调用迭代器的__next__()方法。
class A():
 def __init__(self):
 pass
 def __iter__(self):
 self.num = 0
 return self
 def __next__(self):
 if self.num < 10:
 N = self.num
 self.num += 1
 return N
 else:
 raise StopIteration
a = A()
for i in a:
 print(i) >>> 0 1 2 3 4 5 6 7 8 9

#等同于：先调用对象的__iter__()方法，返回一个迭代器，然后不断的调用迭代器的__next__()方法,调用完返回StopIteration，结束迭代
b = iter(a)
while True:
 try:
 next(b)
 except:
 raise StopIteration

0 1 2 3 4 5 6 7 8 9
Traceback (most recent call last):
 File "<stdin>", line 3, in <module>
 File "<stdin>", line 13, in __next__
StopIteration