迭代器与生成器

迭代器

可迭代对象：

list，str，tuple，etc. —> for…in… 遍历 —> 遍历（迭代）

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

现在，我们就可以说，实现了迭代器协议的对象就是可迭代对象。

如何实现？

• 通过在对象内部定义一个__iter__方法。

li = [1, 2, 3]
sr = "abcd"
li_iter = sr.__iter__()  # <---> iter(sr)
print(li_iter.__next__())  # <---> next(li_iter)
print(li_iter.__next__())
print(li_iter.__next__())
print(next(li_iter))
print(next(li_iter))  # 当迭代次数超过元素个数时，引起StopIteration异常

# a
# Traceback (most recent call last):
# b
#   File "D:/python/test1/day11.py", line 16, in <module>
# c
#     print(next(li_iter))
# d
# StopIteration

for i in 100:
    print(i)  # 报错，整型、浮点型、布尔型不可以被迭代
    
# 可迭代对象测试
from collections import Iterable  # 使用instance()来判断一个对象是否可迭代
print(isinstance([], Iterable))  # True
print(isinstance(str(), Iterable))  # True
print(isinstance({}, Iterable))  # True
print(isinstance(set(), Iterable))  # True
print(isinstance(123, Iterable))  # False
print(isinstance(True, Iterable))  # False

自定义一个类，其可以容纳数据，测试该类的可迭代性

from collections import Iterable
class IterTest:
    def __init__(self):
        self.names = []
    def add(self, name):
        self.names.append(name)
  # def __iter__(self):  # 加入__iter__后print输出True，itertest为可迭代对象
  #     return self.names.__iter__()
itertest = IterTest()
itertest.add("Tom")
itertest.add("Jack")
itertest.add("Mary")

print("是否为可迭代对象：", isinstance(itertest, Iterable))  # False
for i in itertest:  # 加入__iter__方法后可以遍历出结果
    print(i)
# Tom
# Jack
# Mary
# 通过迭代器迭代
itertest_iter = iter(itertest)
print(next(itertest_iter))
print(next(itertest_iter))
print(next(itertest_iter))
# Tom
# Jack
# Mary

回顾之前说的__iter__方法，其可以为我们提供一个迭代器。

在迭代一个可迭代对象的时候，实际上就是获取该对象提供的一个迭代器。然后通过该迭代器依次获取对象的每一个数据。

for item in 可迭代对象 循环的本质

就是通过iter()函数获取可迭代对象的Iterable的迭代器，然后对获取到迭代器不断调用next()方法来获取下一个值，并将其赋值给item，当遇到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
for i in test(2):
    print(i)
# 3
# 4
# 5
# 6

应用场景

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

demo：

斐波那契数列

class FibIterator(object):
    """斐波那契数列迭代器"""
    def __init__(self, n):
        # 记录生成的斐波那契数列的个数
        self.n = n
        # 记录当前的索引
        self.current_index = 0
        # 记录两个初始值
        self.num1 = 0
        self.num2 = 1

    def __next__(self):
        """调用next()函数来获取下一个数"""
        if self.current_index < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            self.current_index += 1
            return num
        else:
            raise StopIteration

    def __iter__(self):
        return self

fib = FibIterator(10)
for i in fib:
    print(i)

生成器

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

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

创建一个生成器

列表[] —> ()

li = [x**2 for x in range(6)]
print(li)  [0, 1, 4, 9, 16, 25]
gen = (x**2 for x in range(6))
gen2 = (x**2 for x in range(6))
print("通过next()函数取得下一个值")
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 4
print(next(gen))  # 9
print(next(gen))  # 16
print(next(gen))  # 25
print("通过for遍历")
for i in gen2:
    print(i, end=' ')
# 0 1 4 9 16 25 

生成器函数

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

demo:

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
# Traceback (most recent call last):
#   File "D:/python/test1/day11.py", line 150, in <module>
#     print(next(f))
# StopIteration

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

在一个生成器中，如果return后有返回值，那么这个值就是异常的说明，而不是函数的返回值。

def foo():
    yield 1
    yield 2
    return "Error"
    yield 3
f = foo()
print(next(f))  
print(next(f))
print(next(f))  
# Traceback (most recent call last):
# 1
#   File "D:/python/test1/day11.py", line 150, in <module>
# 2
#     print(next(f))  
# StopIteration: Error

构造一个产生无穷奇数的生成器

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

o = odd()
for i in range(10):
    print(next(o), end=' ')  # 1 3 5 7 9 11 13 15 17 19 

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

class Odd:
    def __init__(self):
        self.n = -1
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 2
        return self.n
o = Odd()
for i in range(10):
    print(next(o), end=' ')  # 1 3 5 7 9 11 13 15 17 19 

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

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

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

None

• close()
  • 手动关闭生成器函数，后面调用会引起StopIteration异常

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

o = odd()
print(next(o))
o.close()
print(next(o))
# 1
# Traceback (most recent call last):
#   File "D:/python/test1/day11.py", line 207, in <module>
#     print(next(o))
# StopIteration

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

def gen():
    value = 0
    while True:
        receive = yield value
        if receive == "e":
            break
        value = "got: %s" % receive
# send()的作用就是使receive赋值为其所传送的值，然后让生成器执行到下一个yield
g = gen()  # 创建生成器对象
print(g.send(None))  # 0 唤醒生成器
print(g.send('aaa'))  # got: aaa
print(g.send(123))  # got: 123

• 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, "66666"))
# 0
# None 1
#   File "D:/python/test1/day11.py", line 220, in <module>
#     print(obj.throw(Exception, "66666"))
#   File "D:/python/test1/day11.py", line 212, in gen
#     temp = yield i
# Exception: 66666