迭代器與生成器

迭代器

可迭代對象：

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