生成器与迭代器

生成器与迭代器

[i * i for i in range(8)]  #列表推导器
#[0, 1, 4, 9, 16, 25, 36, 49]

(i * i for i in range(8))  #生成器表达式
#<generator object <genexpr> at 0x00000133C3945C00>

生成器函数

上面使用类似生成式的语法得到的生成器被称为生成器表达式。此外，当推算的算法比较复杂时，还可以使用生成器函数得到生成器。
生成器函数中通过关键字yield返回推算出的元素。生成器函数与普通函数的区别在于：当调用内置函数next（）或使用for-in语句迭代时，执行完yield语句就会将生成器函数挂起，下次会从挂起的地方继续执行。

def fib(n):
	i = 0
	a, b = 1, 1
	while i < n:
		print(a, end = ',')
		a, b = b, a  + b
		i += 1

fib(6)
#1, 1, 2, 3, 5, 8

def fib(n):
	i = 0
	a, b = 1, 1
	while i < n:
		yield a
		a, b = b, a  + b
		i += 1

fib(6)
#<generator object fib at 0x00000133C3945C78>

gf = fib(6)
print(next(gf))    #1  
print(next(gf))    #1  
print(next(gf))    #2 
print(next(gf))    #3  
print(next(gf))    #5  
print(next(gf))    #8   
print(next(gf))    #StopIteration 

gf = fib(6)
for item in gf:
	print(item)

#1
#1
#2
#3
#5
#8

迭代器

1.可以用于for-in语句的对象被称为可迭代对象（Iterable）对象
2.可以调用内置函数isinstance()判断一个对象是否是可迭代对象。标准库模块collection中的类Iterable用于表示可迭代对象。

from collections import Iterable
print(isisnstance([1, 2, 3], Iterable))   #True
print(isisnstance('abc'], Iterable))   #True
print(isisnstance((i * i for i in range91, 7)), Iterable))   #True

如果一个可迭代对象可以作为内置函数next（）的实参从而支持惰性推算，那么该对象被称为迭代器（Iterable）对象。
对于range、列表、元组、字符串。字典和集合等可迭代对象，都不可作为内置函数next（）的实参，而生成器可以。所以，生成器是迭代器的一种。
可以调用内置函数isinstance（）判断一个对象是否是迭代对象。标准库模块collections中的类Iterable用于表示迭代器对象。

L = [1, 2, 3]
next(L)
#TypeError: 'list' object is not an iterator

s = 'abc'
next(s)
#TypeError: 'str' object is not an iterator

from collections import Iterator
print(isinstance(L, Iterator))
print(isinstance(L, Iterator))
#False
#False

print(isinstance((i * i dor i in range(1, 7)), Iterator))
#True

可以调用内置函数iter()把不支持惰性推算的可迭代对象转换为迭代器对象。

iter_L = ietr(L)
iter_s = iter(s)

print(isinstance(iter_L, Iterator))   #True
print(isinstance(iter_s, Iterator))   #True

print(next(iter_L))   #1
print(next(iter_L))   #2
print(next(iter_L))   #3
print(next(iter_L))   #StopIteration

print(next(iter_s))   #a
print(next(iter_s))   #b
print(next(iter_s))   #c
print(next(iter_s))   #StopIteration

如果一个同时对象实现了特殊方法__iter__()和___next__()，那么该对象也被称为迭代器对象。如果将该对象用于for-in语句首先会调用特殊方法__iter__()返回一个可迭代对象，然后不断调用该可迭代对象的特殊方法__next__()返回下一次迭代的值，知道遇到StopIteration时退出循环。

class MyIterator(object):
	def __init__(self):
		self.data = 0

	def __iter__(self):
		return self

	def __next__(self):
		if self.data >5:
			raise StopIteration()
		else:
			self.data += 1
			return self.data


for item in MyIterator():
	print(item)
#1
#2
#3
#4
#5
#6

class Fib(object):
	def __init__(self):
		self.a, self.b = 0, 1

	def __iter__(self):
		return self
		
	def __next__(self):
		self.a, self.b = self.b, self.a + self.b
		if self.a >50:
			raise StopIteration()
		return self.a

for item in Fib():
	print(item)

#1
#1
#2
#3
#5
#8
#13
#21
#34

for-in语句在默认情况下不能用于自定义类对象的实例对象。
1.如果想要for-in语句可以用于自定义对象的实例对象，必须在自定义类对象中实现特殊方法__iter__()和__next__()。for-in语句首先会调用特殊方法__iter__()返回一个可迭代对象，然后不断调用可迭代对象的特殊方法__next__()返回下一次迭代的值，直到遇到StopIteration时退出循环。
只实现了特殊方法__iter__()的类对象，被称为可迭代对象；同时实现了特殊方法__iter__()和__next__()的类对象，被称为迭代器类对象。
之所以for-in语句可以用于某些内置类对象（例如：list、tuple、str等）的实例对象，是因为这些内置类对象中都同时实现了特殊方法__iter__)和__next__()。