07生成器與迭代器

 

生成器

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

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

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

In [3]:

L = [x + 1 for x in range(5)]
L

Out[3]:

[1, 2, 3, 4, 5]

In [4]:

g = (x + 1 for x in range(5))
g

Out[4]:

<generator object <genexpr> at 0x000000000BC68620>

 

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

咱們能夠直接打印出list的每個元素，但咱們怎麼打印出generator的每個元素呢？

若是要一個一個打印出來，能夠經過next()函數（or next()）得到generator的下一個返回值：

In [5]:

next(g)

Out[5]:

1

In [6]:

next(g)

Out[6]:

2

In [7]:

next(g)

Out[7]:

3

In [8]:

next(g)

Out[8]:

4

In [9]:

next(g)

Out[9]:

5

In [10]:

next(g)

 

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-10-e734f8aca5ac> in <module>
----> 1next(g)

StopIteration: 

 

generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。

上面這種不斷調用next(g)實在是太變態了，正確的方法是使用for循環，由於generator也是可迭代對象：

In [11]:

g = (x * x for x in range(10))
for n in g:
    print(n, end="; ")

 

0; 1; 4; 9; 16; 25; 36; 49; 64; 81; 

 

因此，咱們建立了一個generator後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤。

 

經過使用yield關鍵字定義

 

生成器對象是經過使用yield關鍵字定義的函數對象，所以，生成器也是一個函數。生成器用於生成一個值得序列，以便在迭代器中使用。

In [12]:

"""
第一是直接做爲腳本執行，
第二是import到其餘的python腳本中被調用（模塊重用）執行。
所以if __name__ == '__main__': 的做用就是控制這兩種狀況執行代碼的過程，
在if __name__ == '__main__':下的代碼只有在第一種狀況下（即文件做爲腳本直接執行）纔會被執行，而import到其餘腳本中是不會被執行的。
"""

def myYield(n):
    while n > 0:
        print('開始生成。。。')
        yield n
        print('完成一次。。。')
        n -= 1
        
if __name__ == '__main__':
    a = myYield(3)
    print('已經實例化生成器對象')
#     a.__next__()
#     print('第二次調用__next__()方法：')
#     a.__next__()

 

已經實例化生成器對象

 

yield 語句是生成器中的關鍵語句，生成器在實例化時並不會被執行，而是等待調用其next()方法纔開始運行。而且當程序運行完yield語句後就會「吼（hold）住」，即保持當前狀態且中止運行，等待下一次遍歷時才恢復運行。

程序運行的結果中的空行後的輸出「已經實例化生成器對象」以前，已經實例化了生成器對象，但生成器並無運行（沒有輸出‘開始生成’）。當第一次手工調用next()方法以後，才輸出‘開始生成’，標誌着生成器已經運行，而在輸出‘’第二次調用next()方法‘’以前並無輸出‘完成一次’，說明yield語句運行以後就當即中止了。而第二次調用next()方法以後，才輸出‘完成一次’，說明生成器的回覆運行是從yield語句以後開始運行的

In [13]:

a.__next__()

 

開始生成。。。

Out[13]:

3

In [14]:

a.__next__()

 

完成一次。。。
開始生成。。。

Out[14]:

2

 

著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數均可由前兩個數相加獲得：

斐波拉契數列用列表生成式寫不出來，可是，用函數把它打印出來卻很容易：

In [15]:

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

In [16]:

fib(5)

 

1
1
2
3
5

Out[16]:

'done'

 

上面的函數和generator僅一步之遙。要把fib函數變成generator，只須要把print(b)改成yield b就能夠了：

In [17]:

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        #print(b)
        yield b
        a, b = b, a + b
        n += 1
    return 'well done'

 

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

In [18]:

f= fib(5)
f

Out[18]:

<generator object fib at 0x000000000BC687D8>

In [19]:

f.__next__()

Out[19]:

1

In [20]:

f.__next__()

Out[20]:

1

In [21]:

f.__next__()

Out[21]:

2

 

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

In [22]:

g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

 

g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: well done

 

生成器在Python中是一個很是強大的編程結構，能夠用更少地中間變量寫流式代碼，此外，相比其它容器對象它更能節省內存和CPU，固然它能夠用更少的代碼來實現類似的功能。如今就能夠動手重構你的代碼了，但凡看到相似

 

def something(): result= [] for ... in ...： result.append(x) return result

均可以用生成器函數來替換：

def iter_something(): result = [] for ... in ...： yield x

 

楊輝三角

期待輸出:

In [23]:

def triangles():
    result = [1]
    while True:
        yield result
        result = [1] + [result[i] + result[i+1] for i in range(len(result)-1)] + [1]

In [24]:

n = 0
results = []
for t in triangles():
    print(t)
    results.append(t)
    n = n + 1
    if n == 10:
        break
if results == [
    [1],
    [1, 1],
    [1, 2, 1],
    [1, 3, 3, 1],
    [1, 4, 6, 4, 1],
    [1, 5, 10, 10, 5, 1],
    [1, 6, 15, 20, 15, 6, 1],
    [1, 7, 21, 35, 35, 21, 7, 1],
    [1, 8, 28, 56, 70, 56, 28, 8, 1],
    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
    print('測試經過!')
else:
    print('測試失敗!')

 

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
測試經過!

 

迭代器

 

能夠直接做用於for循環的數據類型有如下幾種：

一類是集合數據類型,如list,tuple,dict,set,str等 一類是generator ，包括生成器和帶yeild的generator function

這些能夠 直接做用於for循環的對象統稱爲可迭代對象：Iterable 能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator

In [25]:

a = [i for i in range(10)]
next(a)

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-25-8981550fe3e0> in <module>
      1 a = [i for i in range(10)]
----> 2next(a)

TypeError: 'list' object is not an iterator

 

list，dict，str雖然是Iterable，卻不是Iterator。

In [26]:

from collections import Iterator
from collections import Iterable
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
print(isinstance({},Iterable))
print(isinstance('abc',Iterable))

 

False
True
True
True

 

生成器就是一個迭代器

In [27]:

a = (i for i in range(10))
print(next(a))
print(isinstance(a, Iterator))

 

0
True

 

iter()函數 建立迭代器

 

iter（iterable）#一個參數，要求參數爲可迭代的類型

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

In [28]:

print(isinstance({},Iterator))
print(isinstance('abc',Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter('abc'),Iterator))

 

False
False
True
True

 

你可能會問，爲何list、dict、str等數據類型不是Iterator？

這是由於Python的Iterator對象表示的是一個數據流，Iterator對象能夠被next()函數調用並不斷返回下一個數據，直到沒有數據時拋出StopIteration錯誤。能夠把這個數據流看作是一個有序序列，但咱們卻不能提早知道序列的長度，只能不斷經過next()函數實現按需計算下一個數據，因此Iterator的計算是惰性的，只有在須要返回下一個數據時它纔會計算。 Iterator甚至能夠表示一個無限大的數據流，例如全體天然數。而使用list是永遠不可能存儲全體天然數的。

 

小結

 

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

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

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

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

In [29]:

for x in [1, 2, 3, 4, 5]:
    print(x,end=',')

 

1,2,3,4,5,

In [30]:

# 首先得到Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 得到下一個值:
        x = next(it)
        print(x,end=',')
    except StopIteration:
        # 遇到StopIteration就退出循環
        break

 

1,2,3,4,5,