py8 列表生成式迭代器生成器

時間 2019-12-07

標籤 py8 列表生成迭代成器简体版

原文原文鏈接

列表生成式，迭代器&生成器

列表生成式

列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表裏的每一個值加1，你怎麼實現？你可能會想到2種方式html

普通青年版node

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = []
>>> for i in a:b.append(i+1)
... 
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = b
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

原值修改python

a = [1,3,4,6,7,7,8,9,11]

for index,i in enumerate(a):
    a[index] +=1
print(a)

文藝青年算法

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = map(lambda x:x+1, a)
>>> a
<map object at 0x101d2c630>
>>> for i in a:print(i)
... 
2
3
4
5
6
7
8
9
10
11

還有一種叫作列表生成式併發

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

經過列表生成式，咱們能夠直接建立一個列表。可是，受到內存限制，列表容量確定是有限的。並且，建立一個包含100萬個元素的列表，不只佔用很大的存儲空間，因此，若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。app

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

>>> 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的每個元素呢？spa

若是要一個一個打印出來，能夠經過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後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤。

generator很是強大。若是推算的算法比較複雜，用相似列表生成式的for循環沒法實現的時候，還能夠用函數來實現。

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

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

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

注意，賦值語句：

1	`a, b` `=` `b, a` `+` `b`

至關於：

 
         t  
         = 
         (b, a  
         + 
         b)  
         # t是一個tuple 
        
 
         a  
         = 
         t[ 
         0 
         ] 
        
 
         b  
         = 
         t[ 
         1 
         ] 
        

但沒必要顯式寫出臨時變量t就能夠賦值。

上面的函數能夠輸出斐波那契數列的前N個數：

仔細觀察，能夠看出，fib函數其實是定義了斐波拉契數列的推算規則，能夠從第一個元素開始，推算出後續任意的元素，這種邏輯其實很是相似generator。

也就是說，上面的函數和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後的內容輸出後保存斷點返回），再次執行時從上次返回的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

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

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

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

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

 
         >>> 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: done 
        

PEP 342 添加了 .throw(...) 和 .close() 方法（前者的做用是讓調用方拋出異常，在生成器中處理；後者的做用是終止生成器）

關於如何捕獲錯誤，後面的錯誤處理還會詳細講解。

還可經過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")

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

關於yield的別的解析部分：

（1）yield後面能夠加多個數值（能夠是任意類型），但返回的值是元組類型的。

def get():
    m = 0
    n = 2
    l = ['s',1,3]
    k = {1:1,2:2}
    p = ('2','s','t')
    while True:
        m += 1
        yield m
        yield m ,n ,l ,k ,p
        
it = get()
print(next(it)) #1
print(next(it)) #(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))

print(next(it)) #2
print(type(next(it))) #<class 'tuple'>

若是再加一句:

print(type(next(it))) #<class 'int'>  #返回的是整形

因此返回值的類型，應該是當前調用時，yield 返回值的類型。

（2）關於原函數的return部分return的東西變成了StopIteration異常的值。

在一個 generator function 中，若是沒有 return，則默認執行至函數完畢，若是在執行過程當中 return，則直接拋出 StopIteration 終止迭代。

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

#f= fib(10)
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: ---done---

def gen(max):
    b = 123
    a = 0
    while a < max:
        a += 1
        yield a
        return 'done'
    return 'done---'

g = gen(5)
print(next(g))  # 這裏在yield斷點那，還沒執行return
next(g)  # 返回斷點，執行return，拋出異常


1  # next（）的返回值：yield後面跟的參數
Traceback (most recent call last):
  File "H:/python/workspace/day04/generator.py", line 17, in <module>
    next(g)
StopIteration: done   # 異常的值爲return 後的值

（3）yield 能夠還可以接受參數

send()和next()的區別就在於send可傳遞參數給yield表達式，這時候傳遞的參數就會做爲yield表達式的值，因此也能夠認爲next（）等同於send(None)。

send()和next()都有返回值，他們的返回值是當前迭代遇到的yield的時候，yield後面表達式的值，其實就是當前迭代yield後面的參數。

def f(maxx):
    n, a, b = 0, 1, 1
    while n < maxx:
        # print(b)
        y = yield b
        a, b = b, a + b
        n += 1
        print(y)
    return 'error_name'  # 原函數的return變成了迭代完報出錯誤的值(value)  


fi = f(6)  # 將一個函數變成生成器，並賦值給fi，每次迭代的值都是yield右邊的值
print(fi.__next__())  # 運行一次生成器，到yield處中斷，運行下面的程序
print(fi.send('Done'))  # 回到第一次運行的生成器的yield中斷處，並把Done賦予yield，而後執行下面的程序，到yield再次中止
fi.send('Done')  # 若是這句換成print(fi.send('Done')),則會輸出3 
print(fi.send('Done'))  # next和send的返回值都是fi迭代器本次的值

1
Done
2
Done
Done
5

（4）調用一次next是從上次yield到下一次yield結束，並不必定是隻走一遍生成器中的循環

def fun(num):
    i = 1
    while i < num:
        if (i % 2):
            yield i
        i += 1


f = fun(15)
print(next(f))
print(next(f))  # 每一次next不定只走一遍fun的循環，這裏走了兩次
print(f.__next__())

for i in f:  # for循環迭代生成器同理
    print(i)

1
3
5
7
9
11
13

迭代器

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

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

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

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

可使用isinstance()判斷一個對象是不是Iterable對象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

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

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

可使用isinstance()判斷一個對象是不是Iterator對象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

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

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

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

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

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

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

經過__iter__/__next__獲得一些類（容器）中迭代器的理解

Python的迭代器協議須要 __iter__() 方法返回一個實現了 __next__() 方法的迭代器對象。若是你只是迭代遍歷其餘容器的內容，你無須擔憂底層是怎樣實現的。你所要作的只是傳遞迭代請求既可。

class squares:
    def __init__(self, start, stop):
        self.flag = start - 1
        self.value = self.flag
        self.stop = stop
    def __iter__(self):
        self.value = self.flag
        return self  # 返回一個實現了__next__()方法的迭代器對象
    def __next__(self):
        if self.value == self.stop:
            raise StopIteration
        self.value += 1
        return self.value

a = squares(1,5)
b = squares(1,5)
s = 0
while s<=41:
    for i in a:  # 這裏會調用__iter__()而後返回獲得一個迭代器對象，而後一直調用__next__()直到報StopIteration後，循環沒有結束的話從新調用__iter__()返回迭代器對象，而後next
        s= s + i
        print(s)

1
3
6
10
15  #
16
18
21
25
30  #
31
33
36
40
45

到時迭代器中止工做，實現了三圈循環。

能夠得出：

迭代器走完一輪，拋出異常後，再次調用會先進行__iter__(),再進行__next__()。

class Node:
    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        return iter(self._children)

# Example
if __name__ == '__main__':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    # Outputs Node(1), Node(2)
    for ch in root:  # root會先調用__iter__()而後獲得了一個可迭代對象
        print(ch)

這裏的 iter() 函數的使用簡化了代碼， iter(s) 只是簡單的經過調用 s.__iter__() 方法來返回對應的迭代器對象，就跟 len(s) 會調用 s.__len__() 原理是同樣的。

迭代器要注意一點，迭代器只能單次循環

上圖可見，for循環只能輸出一次，第二次什麼也不能輸出，由於迭代器是一個單向的容器，走到尾部以後，不會自動再回到開始位置。

生成器不保留前面的數，只能next取下一個，因此遍歷一遍完了就沒了

關於range和xrange ：

在python2中，有range和xrange之分，range是把數生成列表形式，xrange吧數生成迭代器形式，在python3中，只有range，py3中的range就是py2中的xrange，生成迭代器形式

小結

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

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

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

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

for x in [1, 2, 3, 4, 5]:
    pass

實際上徹底等價於：

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