列表生成式

列表[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))

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))

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-生成器&叠代器