迭代器和生成器

迭代器

可迭代对象：

• list，str，tuple，etc ---->for … in … 遍历---->遍历迭代（迭代）

迭代器协议：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起StopIteration 异常，以终止迭代（只能往下走，不可以回退）

实现了迭代器协议的对象就是可迭代对象

如何实现？

• 通过在对象内部定义一个’_iter_'方法。

可迭代对象的测试

• 使用isinstance()来判断一个对象是否可迭代

from _collections_abc import Iterable
print(isinstance({},Iterable))
print(isinstance(str(),Iterable))
print(isinstance(set(),Iterable))
print(isinstance([],Iterable))
print(isinstance(True,Iterable))
print(isinstance(123,Iterable))
#输出
True
True
True
True
False
False

自定义一个类

from _collections_abc import Iterable


class MyClass:
    def __init__(self):
        self.name = []

    def add(self, name):
        self.name.append(name)

    def __iter__(self): 			#'__iter__'方法可以为我们提供一个迭代器
        return self.name.__iter__()   #通过该迭代器，依次获取对象的每一个数据

my_class = MyClass()
my_class.add('Riku')
my_class.add('All Might')
my_class.add('Tom')

print('是否为可迭代对象：',isinstance(my_class,Iterable))
for i in my_class:
    print(i)
#输出
是否为可迭代对象： True
Riku
All Might
Tom

通过迭代器：

print(my_class)
my_class_iter=iter(my_class)
print(my_class_iter)
print(next(my_class_iter))
print(next(my_class_iter))
print(next(my_class_iter))
#输出
<__main__.MyClass object at 0x02A6EFF0>
<list_iterator object at 0x04DAAF90>
Riku
All Might
Tom

for … in … 循环的本质

就是通过iter()函数获取可迭代对象的Iterable的迭代器，然后对获取到的迭代器不断调用next()

方法来获取下一个值并将其辅助，当遇到StopIteration的异常后退出。

class Test:
    def __init__(self, data=1):
        self.data = data

    def __iter__(self):
        return self

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

for i in Test(1):
    print(i)
#输出
1
2
3
4
5

应用场景

迭代器的核心就是通过next()函数调用下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中提取，而是通过程序按照一定规律计算生成。就意味可以不用依赖一个已有的数据集合，namely，无需将所有的迭代对象数据一次性缓存下来供后续使用。可以节约大量的存储空间

demo：

斐波那契数列

class Fib:
    def __init__(self, n):
        # 记录生成的斐波拉契数列的个数
        self.n = n
        # 记录当前记录的索引
        self.current_index = 0

        self.num1 = 0
        self.num2 = 1

    def __next__(self):
        if self.current_index < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2  # 01 11 12 23 35
            self.current_index += 1
            return num
        else:
            raise StopIteration

    def __iter__(self):
        return self


fib = Fib(10)
for num in fib:
    print(num, end=' ')
#输出
0 1 1 2 3 5 8 13 21 34 

生成器

生成器，利用迭代器，我们可以在每次迭代获取数据时（通过next()方法），按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代的状态需要我们自己记录，进而才能根据当前的状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，可以采用更简便的语法，即，生成器。

生成器是一种特殊的迭代器，它比迭代器更优雅。

li = [i ** 2 for i in range(6)]
print(li)

gen = (i ** 2 for i in range(6))

for i in gen:
    print(i, end=' ')
#输出
[0, 1, 4, 9, 16, 25]
0 1 4 9 16 25 

生成器函数

在函数中如果出现了yield关键字，那么该函数就不再是一个普通函数而是一个生成器函数。

def foo():
    yield 1
    yield 2
    return
    yield 3
f = foo()
print(next(f))  #程序会停留在对应yield 后的语句
print(next(f))
print(next(f))  #当程序遇到return,return后的语句不会再执行，因此报错。
#输出
1
2
StopIteration

next和yield进行匹配。如果遇到return,return后的语句不会再执行，直接抛出StopIteration,终止迭代。

如果return后面有返回值，那么这个值就是异常的说明，而不是函数的返回值

def odd():
    n = 1
    while True:
        yield n
        n += 2


odd_num = odd()
for i in range(1, 6):
    print(next(odd_num))
        
#输出
1
3
5
7
9

通过类手动编写迭代器，实现类似的效果。

class OddIter:
    def __init__(self):
        self.start = -1

    def __iter__(self):
        return self

    def __next__(self):
        self.start += 2
        return self.start


odd = OddIter()
for i in range(6):
    print(next(odd))
#输出
1
3
5
7
9
11

def odd():
    n = 1
    while True:
        yield n
        n += 2


o=odd()
print(help(o))

#输出

Help on generator object:

odd = class generator(object)
 |  Methods defined here:
 |  
 |  __del__(...)
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  close(...)
 |      close() -> raise GeneratorExit inside generator.
 |  
 |  send(...)
 |      send(arg) -> send 'arg' into generator,
 |      return next yielded value or raise StopIteration.
 |  
 |  throw(...)
 |      throw(typ[,val[,tb]]) -> raise exception in generator,
 |      return next yielded value or raise StopIteration.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  gi_code
 |  
 |  gi_frame
 |  
 |  gi_running
 |  
 |  gi_yieldfrom
 |      object being iterated by yield from, or None

• close()
  • 手动关闭生成器

def gen():
    yield 1
    yield 2
    yield 3
    yield 4

g= gen()
print(next(g))
print(next(g))
g.close()
print(next(g))
#输出
1
2
StopIteration

• send()
  • 使receive赋值为其所传送的值，然后让生成器执行到下一个yield
  • 如果生成器未启动，则必须在使用send()前启动生成器，而启动方法可是是gen.next()，也可以是gen.send(None)执行到第一个yield处。之后就可以使用send(para)不断的传入值。
  • 如果是已启动，则sand(para)的作用就是给receive赋值为发送的值(send的参数，然后让生成器执行到下一个yield。

def Gene():  # 生成器函数
    print("ok")
    x = 100
    print(x,0)
    first = yield 50  # 这里就是send函数的关键
    # send所传递的值其实就是给 =号左边的左值赋值
    print(first,1)

    second = yield x  # 这里试第二个断点
    print(second,2)

    z = '123123123'
    third = yield z
    print(third,4)


inst = Gene()
output1 = inst.send(None)
print(output1,'a')
output2 = inst.send(30)
print(output2,'b')
output3 = inst.send(None)
print(output3)
#输出
ok
100 0
50 a
30 1
100 b
None 2
123123123

• throw()

  • 手动抛出异常

def gen():
    i = 0
    while i < 5:
        temp = yield i
        print(temp, end=' ')
        i += 1


obj = gen()
print(next(obj))
print(next(obj))
print(obj.throw(Exception, '6666'))
#输出
0
None 1
Exception: 6666