Python3-生成器&叠代器
列表生成式
列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],要求把列表裏的每個值加1，如何實現？
>>> a = [i+1 for i in range(10)] >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
這就叫列表生成。
生成器
通過列表生成式，我們可以直接創建一個列表。但是，受到內存限制，列表容量肯定是有限的。而且，創建一個包含100萬元素的列表，不僅占用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大所述元素占用的空間都白白浪費了。
所以，如果列表元素可以按照某種算法推算出來，那我們是否可以在循環的過程中不斷推算出後續的元素呢？這樣就不必創建完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱為生成器：generator。
要創建一個generator，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[ ]改成( )，就創建了一個genreator：
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630>
創建L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。
我們可以直接打印出list的每一個元素，但我們怎麽打印出generator的每一個元素呢？
如果要一個個打印出來，可以通過next()函數獲得generator的下一個返回值：
>>> next(g) 0 >>> next(g) 1 >>> next(g) 4 >>> next(g) 9 >>> next(g) 16 >>> next(g) 25 >>> next(g) 36 >>> next(g) 49 >>> next(g) 64>>> next(g) 81 >>> next(g) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
我們講過，generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。
上面不斷調用next（g）太麻煩，正確的方式是使用for循環，因為generator也是可叠代對象：
>>> g = (x * x for x in range(10)) >>> for n in g: ... print(n) ... 0 1 4 9 16 25 36 49 64 81
generator非常強大。如果推算的算法比較復雜，用類似列表生成式的for循環無法實現的時候，還可以用函數來實現。
比如，著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契數列用列表生成式寫不出來，但是，用函數把它打印出來卻很容易：
def fib(max): n, a, b = 0, 0, 1 while n < max: print(b) a, b = b, a + b n = n + 1 return ‘done‘
a, b = b, a + b #相當於 t = (b, a + b) # t是一個tuple a = t[0] b = t[1]
上面的函數可以輸出斐波那契數列的前N個數：
>>> fib(10) 1 1 2 3 5 8 13 21 34 55 done
上面的函數和generator僅一步之遙。要把fib函數變成generator，只需要把print(b)改為yield b就可以了：
def fib(max): n,a,b = 0,0,1 while n < max: #print(b) yield b a,b = b,a+b n += 1 return ‘done‘
這就是定義generator的另一種方法。如果一個函數定義中包含yield關鍵字，那麽這個函數就不再是一個普通函數，而是一個generator：
>>> f = fib(6) >>> f <generator object fib at 0x104feaaa0>
generator和函數的執行流程不一樣。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
data = fib(10) print(data) print(data.__next__()) print(data.__next__()) print("幹點別的事") print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) #輸出 <generator object fib at 0x101be02b0> 1 1 幹點別的事 2 3 5 8 13
更多應用
import time def tail(filename): f = open(filename) f.seek(0, 2) # 2--> 從文件末尾算起 while True: line = f.readline() #讀取文件中新的文本行 if not line: time.sleep(0.1) continue yield line tail_g = tail(‘test1‘) for line in tail_g: print(line)監聽文件輸入
send
def generator(): print(123) content = yield 1 print(‘======‘, content) print(456) yield 2 g = generator() ret = g.__next__() # 跟 ret = g.send(None) 一樣效果 print(‘***‘, ret) ret = g.send(‘hello‘) # send的效果和next一樣 print(ret) # next的時候，把yield 的值返回到外面 # send的時候，把send 的值返回到裏面！
def averager(): total = 0.0 count = 0 average = None while True: num = yield average count += 1 total += num average = total / count g_avg = averager() g_avg.send(None) print(g_avg.send(10)) print(g_avg.send(30)) print(g_avg.send(5))計算移動平均值（1）
def init(func): #在調用被裝飾生成函數的時候先用next激活生成器 def inner(): g = func() next(g) return g return inner @init def averager(): total = 0.0 count = 0 average = None while True: num = yield average count += 1 total += num average = total / count g_avg = averager() # g_avg.send(None) print(g_avg.send(10)) print(g_avg.send(30)) print(g_avg.send(5))計算移動平均值（2） 帶裝飾器
yield from
yield from iterable 本質上等於 for item in iterable: yield item的縮寫版
def gen1(): for c in ‘AB‘: yield c for i in range(3): yield i print(list(gen1())) def gen2(): yield from ‘AB‘ yield from range(3) print(list(gen2()))
均輸出：
[‘A‘, ‘B‘, 0, 1, 2]
叠代器
python中的for循環
要了解for循環是怎麽回事兒，咱們還是要從代碼的角度出發。
首先，我們對一個列表進行for循環。
for i in [1,2,3,4]: print(i)
上面這段代碼肯定是沒有問題的，但是我們換一種情況，來循環一個數字1234試試
for i in 1234 print(i) 結果： Traceback (most recent call last): File "test.py", line 4, in <module> for i in 1234: TypeError: ‘int‘ object is not iterable
看，報錯了！報了什麽錯呢？“TypeError: ‘int‘ object is not iterable”，說int類型不是一個iterable，那這個iterable是個啥？
叠代和可叠代協議
什麽叫叠代
現在，我們已經獲得了一個新線索，有一個叫做“可叠代的”概念。
首先，我們從報錯來分析，好像之所以1234不可以for循環，是因為它不可叠代。那麽如果“可叠代”，就應該可以被for循環了。
這個我們知道呀，字符串、列表、元組、字典、集合都可以被for循環，說明他們都是可叠代的。
from collections import Iterable l = [1,2,3,4] t = (1,2,3,4) d = {1:2,3:4} s = {1,2,3,4} print(isinstance(l,Iterable)) print(isinstance(t,Iterable)) print(isinstance(d,Iterable)) print(isinstance(s,Iterable))
#from collections import Iterator
#l = [1,2,3,4]
#print(isinstance(l,Iterator))
結合我們使用for循環取值的現象，再從字面上理解一下，其實叠代就是我們剛剛說的，可以將某個數據集內的數據“一個挨著一個的取出來”，就叫做叠代。
可叠代協議
我們現在是從結果分析原因，能被for循環的就是“可叠代的”，但是如果正著想，for怎麽知道誰是可叠代的呢？
假如我們自己寫了一個數據類型，希望這個數據類型裏的東西也可以使用for被一個一個的取出來，那我們就必須滿足for的要求。這個要求就叫做“協議”。
print(dir([1,2])) print(dir((2,3))) print(dir({1:2})) print(dir({1,2}))
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘] [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘count‘, ‘index‘] [‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘] [‘__and__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__iand__‘, ‘__init__‘, ‘__ior__‘, ‘__isub__‘, ‘__iter__‘, ‘__ixor__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__or__‘, ‘__rand__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__ror__‘, ‘__rsub__‘, ‘__rxor__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__sub__‘, ‘__subclasshook__‘, ‘__xor__‘, ‘add‘, ‘clear‘, ‘copy‘, ‘difference‘, ‘difference_update‘, ‘discard‘, ‘intersection‘, ‘intersection_update‘, ‘isdisjoint‘, ‘issubset‘, ‘issuperset‘, ‘pop‘, ‘remove‘, ‘symmetric_difference‘, ‘symmetric_difference_update‘, ‘union‘, ‘update‘]結果
總結一下我們現在所知道的：可以被for循環的都是可叠代的，要想可叠代，內部必須有一個__iter__方法。
接著分析，__iter__方法做了什麽事情呢？
print([1,2].__iter__()) 結果 <list_iterator object at 0x1024784a8>
執行了list([1,2])的__iter__方法，我們好像得到了一個list_iterator，現在我們又得到了一個新名詞——iterator。
iterator，這裏給我們標出來了，是一個計算機中的專屬名詞，叫做叠代器。
叠代器
什麽叫“可叠代”之後，又一個歷史新難題，什麽叫“叠代器”？
雖然我們不知道什麽叫叠代器，但是我們現在已經有一個叠代器了，這個叠代器是一個列表的叠代器。
我們來看看這個列表的叠代器比起列表來說實現了哪些新方法，這樣就能揭開叠代器的神秘面紗了吧？
‘‘‘ dir([1,2].__iter__())是列表叠代器中實現的所有方法，dir([1,2])是列表中實現的所有方法,都是以列表的形式返回給我們的，為了看的更清楚，我們分別把他們轉換成集合， 然後取差集。 ‘‘‘ #print(dir([1,2].__iter__())) #print(dir([1,2])) print(set(dir([1,2].__iter__()))-set(dir([1,2]))) 結果： {‘__length_hint__‘, ‘__next__‘, ‘__setstate__‘}
我們看到在列表叠代器中多了三個方法，那麽這三個方法都分別做了什麽事呢？
iter_l = [1,2,3,4,5,6].__iter__() #獲取叠代器中元素的長度 print(iter_l.__length_hint__())
#根據索引值指定從哪裏開始叠代 print(‘*‘,iter_l.__setstate__(4))
#一個一個的取值 print(‘**‘,iter_l.__next__()) print(‘***‘,iter_l.__next__())
這三個方法中，能讓我們一個一個取值的神奇方法是誰？
沒錯！就是__next__
在for循環中，就是在內部調用了__next__方法才能取到一個一個的值。
那接下來我們就用叠代器的next方法來寫一個不依賴for的遍歷。
l = [1,2,3,4]
l_iter = l.__iter__()
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
這是一段會報錯的代碼，如果我們一直取next取到叠代器裏已經沒有元素了，就會拋出一個異常StopIteration，告訴我們，列表中已經沒有有效的元素了。
這個時候，我們就要使用異常處理機制來把這個異常處理掉。
l = [1,2,3,4] l_iter = l.__iter__() while True: try: item = l_iter.__next__() print(item) except StopIteration: break
那現在我們就使用while循環實現了原本for循環做的事情，我們是從誰那兒獲取一個一個的值呀？是不是就是l_iter？好了，這個l_iter就是一個叠代器。
叠代器遵循叠代器協議：必須擁有__iter__方法和__next__方法。
小結：
可叠代對象：
擁有__iter__方法 （遵循可叠代協議），也就是說可以進行for循環的對象
例如：range()，str，list，tuple，dict，set
特點：惰性運算
叠代器Iterator：
擁有__iter__方法和__next__方法
例如：iter(range), iter(str), iter(tuple) 生成器，（列表生成式，帶yield函數）
#iter()函數可以將可叠代對象變為叠代器
生成器Generator：
本質：叠代器，所以擁有__iter__方法和__next__方法
特點：惰性運算，開發者自定義
使用生成器的優點：
1。延遲計算，一次返回一個結果，也就是說，他不會一次生成所有的結果，這對於大數據量處理，將會非常有用。
#列表解析 sum([i for i in range(100000000)])#內存占用大,機器容易卡死 #生成器表達式 sum(i for i in range(100000000))#幾乎不占內存
Python3-生成器&叠代器