迭代器與生成器

時間 2019-11-09

標籤迭代與生成器简体版

原文原文鏈接

迭代器

咱們已經知道，能夠直接做用於for循環的數據類型有如下幾種：python

一類是集合數據類型，如list、tuple、dict、set、str等；算法

一類是generator，包括生成器和帶yield的generator function。編程

這些能夠直接做用於for循環的對象統稱爲可迭代對象：Iterable。併發

而生成器不但能夠做用於for循環，還能夠被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示沒法繼續返回下一個值了。函數

*能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator。工具

生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。spa

把list、dict、str等Iterable變成Iterator可使用iter()函數。線程

這是由於Python的Iterator對象表示的是一個數據流，Iterator對象能夠被next()函數調用並不斷返回下一個數據，直到沒有數據時拋出StopIteration錯誤。能夠把這個數據流看作是一個有序序列，但咱們卻不能提早知道序列的長度，只能不斷經過next()函數實現按需計算下一個數據，因此Iterator的計算是惰性的，只有在須要返回下一個數據時它纔會計算。code

Iterator甚至能夠表示一個無限大的數據流，例如全體天然數。而使用list是永遠不可能存儲全體天然數的。協程

迭代協議

迭代器協議是指：對象必須提供一個next方法，執行該方法要麼返回迭代中的下一項，要麼就引發一個StopIteration異常，以終止迭代（只能日後走不能往前退）
可迭代對象：實現了迭代器協議的對象（如何實現：對象內部定義一個__iter__()方法）
協議是一種約定，可迭代對象實現了迭代器協議，python的內部工具（如for循環，sum，min，max函數等)使用迭代器協議訪問對象。
for循環的本質就是遵循迭代器協議去訪問對象，那麼for循環的對象確定都是迭代器。
不可迭代對象：字符串，列表，元組，字典，集合，文件對象。只不過經過for循環，調用了他們內部的__iter__方法,把他們變成了可迭代對象。

特色：

1.生成器是可迭代對象

2.實現了延遲計算，看內存(按需，執行)

3.生成器本質和其餘類型同樣，都是實現了迭代器協議，只不過生成器是一邊計算，一邊生成，從而節省內存空間，其他的可迭代對象可沒有好處。

小結

凡是可做用於for循環的對象都是Iterable類型；

凡是可做用於next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；

集合數據類型如list、dict、str等是Iterable但不是Iterator，不過能夠經過iter()函數得到一個Iterator對象。

Python的for循環本質上就是經過不斷調用next()函數實現的

生成器

經過列表生成式，咱們能夠直接建立一個列表。可是，受到內存限制，列表容量確定是有限的。並且，建立一個包含100萬個元素的列表，不只佔用很大的存儲空間，若是咱們僅僅須要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。

因此，若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。

生成器就是迭代器，能夠理解爲一種數據類型，這種類型自動實現了迭代器協議.（其餘的數據類型須要調用本身內置的__iter__方法），因此生成器就是可迭代對象。

生成器給了咱們什麼好處

Python使用生成器對延遲操做提供了支持。所謂延遲操做，是指在須要的時候才產生結果，而不是當即產生結果。這也是生成器的主要好處。

生成器小結：

是可迭代對象
實現了延遲計算
生成器本質和其餘的數據類型同樣，都是實現了迭代器協議，只不過生成器附加了一個延遲計算省內存的好處，其他的可迭代對象可沒有這點好處。

建立一個生成器

要建立一個generator，有不少種方法。第一種方法很簡單，只要把一個列表生成式的[]改爲()，就建立了一個generator：

1 t = [x+1 for x in range(4)]
2 
3 print(t)
4 
5 t = (x+1 for x in range(4))
6 
7 print(t)

第一個t是一個list 第二個t是一個generator。咱們可使用for循環將list中的每一個元素取出來，可是要取出generator中的元素，通常來講是使用__next__()方法，可是每次使用只能打印出一個元素。當元素的數據量過於龐大時，也可使用for方法。這只是定義generator的一種方法。除了這個方法，咱們還能夠經過在函數中添加yiled關鍵字來將函數改變成generator。例如咱們能夠用生成器寫一個斐波那契數列。

 1 def fib(max):
 2     n,a,b = 0,0,1
 3 
 4     while n < max:
 5         #print(b)
 6         yield  b #只要是含有yield關鍵字就是生成器 能夠yield屢次 yield保存函數的狀態
 7         a,b = b,a+b
 8 
 9         n += 1
10 
11 t = fib(10)
12 
13 print(t.__next__()) #生成器自動實現了迭成器,因此會有__next__()方法。
14 print(t.__next__()) #運行一次，至關於保存的是上一次內存裏狀態的結果

這裏，最難理解的就是generator和函數的執行流程不同。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

 1 data = fib(10)
 2 print(data)
 3 
 4 print(data.__next__())
 5 print(data.__next__())
 6 print("乾點別的事")
 7 print(data.__next__())
 8 print(data.__next__())
 9 print(data.__next__())
10 print(data.__next__())
11 print(data.__next__())
12 
13 #輸出
14 <generator object fib at 0x101be02b0>
15 1
16 乾點別的事
17 3
18 8

在上面fib的例子，咱們在循環過程當中不斷調用yield，就會不斷中斷。固然要給循環設置一個條件來退出循環，否則就會產生一個無限數列出來。

一樣的，把函數改爲generator後，咱們基本上歷來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代。

可是用for循環調用generator時，發現拿不到generator的return語句的返回值。若是想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中。

還可經過yield實如今單線程的狀況下實現併發運算的效果

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import time
def consumer(name):
    print("%s 準備吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]來了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子開始準備作包子啦!")
    for i in range(10):
        time.sleep(1)
        print("作了2個包子!")
        c.send(i)
        c2.send(i)

producer("alex")

經過生成器實現協程並行運算

send觸發yield返回值原理，一下面的代碼爲例

 1 def consumer(name):
 2     print("%s 準備吃包子啦!" %name)
 3     while True:
 4        baozi = yield
 5 
 6        print("包子[%s]來了,被[%s]吃了!" %(baozi,name))
 7 
 8 c = consumer("alex")
 9 
10 c.__next__()
11 c.send("韭菜餡")