叠代器

為什麽要用叠代器？

提供了一種不依賴索引的取值方式，使一些不具有索引屬性的對象也能遍歷輸出
相比列表，叠代器的惰性計算更加節約內存。
但是它無法有針對性地指定取某個值，並且只能向後取值。

>>> from collections import Iterable
>>> isinstance([],Iterable)
True

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

註意這兩個單詞：‘Iterable’和‘Iterator’

老師區分可叠代對象和叠代器的方法，就是對象是否內置.__iter__方法。而這個方法的運行，也就是xxx.__iter__()，被賦值給一個i。i = xxx.__iter__
那麽這個i就成為一個叠代器。這個過程也可以表示為i = iter(xxx)
叠代器本身就有一個i.__next__方法，其實就相當於next(i)

• Iterable：表示這個對象是“可以被叠代的”。比如說list、dict、str都是Iterable，但是根據上面代碼可以發現，list、dict、str並不能算叠代器。

• Iterator：叠代器對象。定義叠代器對象的時候，要有“數據流”的概念。叠代器和可叠代對象的差別就在於，叠代器是一個數據流，可以看成是一個有序序列，我們不知道序列的長度，只能通過next()

  函數對他進行不斷叠代，直到爆出StopIteration的錯誤提示.

其實這個StopIteration並不能算一個錯誤，只是一個提示，表示這個叠代器已經被叠代完了。這時候就需要使用try……except……函數來規避掉這個錯誤，在出現StopIteration的時候自動跳出叠代。

可叠代對象轉換成叠代器： iter()

小結：

凡是可以使用for循環的，都是Iterabale；
凡是可以使用next()方法的都是Iterator，叠代器代表一個惰性計算（無限有限皆可）序列，比方說：全體自然數集合就是一個Iterator；
一個叠代器被iter()之後，仍然是一個叠代器

for x in [1,2,3,4,5,6]:
    print (x)

print(‘======================‘)

it = iter([1,2,3,4,5,6])
while True:
    try:
        print(next(it))
    except StopIteration:
        break
 

以上兩段代碼輸出結果相同，所以我們就能理解for方法的運行原理了

生成器

• 關鍵字：yield

為什麽要使用生成器，什麽是生成器？

可循環的類型（Iteratable）比如list，占用內存空間較大，當你想要其中的一個元素的時候只能將list放在內存裏，根據索引去獲取，生成器本質就是一個叠代器，但是我們知道叠代器是可以循環出來的，每次都可以只輸出一個值，節約了內存空間。
如果一個叠代對象，他後面的每個值都是可以根據一定計算獲得的。我們是否可以在循環的過程中不斷推算出後續的元素，這樣就不必創建list，節省了大部分空間。
這種一邊循環一邊計算的機制，就是生成器：generator

如何創建一個生成器

• 將列表生成式的[]改成()

>>> 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 0x0000006CC7E0D1A8>

列表生成後，list可以直接打印出來，但是generator的叠代器屬性，每個元素需要用next()函數獲取

 >>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9

以上這種調用方式，手工操作部分太多了，所以正確的調用應該是使用for循環：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> for i in g:
…     print(i)
…
16
25
36
49
64
81

啊哈哈哈哈，側面反映了叠代器的單項輸出性質，只能叠代下一個。這裏還可以註意到，用for調用generator的時候，不需要擔心StopIteration錯誤

舉個栗子：斐波拉契數列

函數生成斐波拉契數列，並註釋邏輯：

# 函數生成斐波拉契數列
def fibonacci(max):
    n, a, b = 0, 0, 1   #這裏的n用於計數，取最大數用
                        #a是前置數，用於配合b獲取最開始的兩個數字
                        #b是第一個數
    while n < max:      #當n未達到max的時候
        print(b)        #打印數字b，後面可以看到，b的值是前兩個數相加的和
        a, b = b, a + b #對a，b分別進行賦值，a是原來的b，b是前兩數相加獲得後的和
        n = n + 1       #n的計數加一
    return ‘done‘

這時候執行fibonacci（num），得到的結果就是一個最大長度為num的fibonacci數列了。
而想要把這個函數改成一個generator，其實只要通過一句yield就可以:

# 函數生成斐波拉契生成器
def fibonacci(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
        return ‘done‘
print(fibonacci(10))

結果為：

<generator object fibonacci at 0x000000D75546D1A8>

Process finished with exit code 0

這裏的fibonacci已經不再是一個函數了，而是一個生成器，他的結果需要被循環出來，而他本身就作為一個方法被儲存在某個變量裏。

f = fibonacci(6)
for i in f :
    print(i)

用yield返回結果的執行流程

使用了yield之後，函數就變成了生成器。我們原先認為函數運行到return、或者函數的最後一行語句就返回。但是添加了yield之後的生成器不一樣，在每次調用了next()執行，遇到yield就返回，再次執行時，從上次返回的yield開始繼續執行

在一個函數中，可以有多個yield，但是這種不太常見，在我的理解裏，yield就有點像IDE當中的debug斷點，在指定斷點輸出一個值。但是這個斷點越多越復雜，反而會不好，因為他最終返回的生成器是一個同類數據流，當你這個數據流中的數據出現兩種，就不太適合被再次加工了。
所以一般用一個yield來定義一束數據流（生成器），然後通過生成器具有的叠代器特性來逐個輸出處理數據。起到節約內存的作用。

註意：yield有時候會作為一個傳參工具（下文會細說，搭配.send()使用，被稱為協程函數），這時候的yield會被放在一個函數中比較靠前位置，但是函數本身暫時沒有可以輸出的值，這時候就需要提前使用next()方法，將生成器初始化到yield的位置
比較優秀的方法，是使用裝飾器，提前將函數next()或者g.send(None)一次，並且方便後面的生成器運行調用:

def init(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        next(res)
        return res
    return wrapper

@init

如果上次的yield是最後一個，並且生成器是一個被while包圍的函數，就從上次結束的yield處繼續下次循環，仍然遇到這個yield就輸出返回。

>>> def odd():
…     print(‘step1‘)
…     yield 1
…     print(‘step2‘)
…     yield 2
…     print(‘step3‘)
…     yield 3
>>> o = odd()
>>> next(o)
step1
1
>>> next(o)
step2
2
>>> next(o)
step3
3

實驗記錄：

>>> def foo():
…     print(‘llllll‘)
…     yield 3
…     print(‘wwwwww‘)
  File "<stdin>", line 4
    print(‘wwwwww‘)
                  ^
IndentationError: unindent does not match any outer indentation level

yield後面跟返回的值如果不用括號括起來，容易報錯，註意養成習慣

作業代碼以及註釋：

#模擬管道功能，將cat的處理結果作為grep的輸入
#從文件中獲取想要的數據
def cat(file_name):         #傳參獲得目標文件名
    with open(file_name,‘r‘) as f:
        res = iter(f.readlines())
    return res
#通過readlines方法獲取文件的行集合list，
#並且將這個集合生成為一個叠代器返回給函數


#傳參獲取目標關鍵字，文件內容叠代器，
def grep(key_str,iterator):
    for i in iterator:
    #叠代文件內容並且匹配關鍵字
        if key_str in i.strip():
            #匹配到後輸出關鍵字
            print (i.strip())

# 調用函數階段：
# grep(‘apple‘,cat(‘a.txt‘))

協程函數

如果函數內yield的表達形式為var= yield，那麽必須在往生成器函數中傳參前，next(g)或者e.send(None)
因為協程函數中，需要將函數初始化暫停至yield所在點，然後再進行生成器輪巡運算。

面向過程編程

在提協程函數的時候，還需要提一個面向過程編程思想：
流水式的變成思想，在設計程序時，需要把整個流程設計出來。
這種思想的優缺點：

• 優點：
  體系結構更加清晰
  簡化程序的復雜度
• 缺點：
  可擴展性差，一條流程只能給一組功能使用。

作業以及代碼註解：

# 定義一個可以不斷傳入（send方法）網址來進行爬取數據的生成器函數
# 定義一個配合協程函數的裝飾器
def yield_next(func):
    def wrapper(*arg,**kwargs):
        res = func(*arg,**kwargs)
        next(res)
        #註意，這裏仍然需要返回res給函數wrapper
        #如果缺少這步，下方調用return wrapper的時候無效
        return res
    return wrapper
#模塊加載
from urllib.request import urlopen

@yield_next
def get_url():
    while True:
        url = yield
        #外部傳值給yield 相當於yield 統一資源定位器，並且url能傳入新的值
        url_res = urlopen(url)      #爬取url指定的頁面內容
        webLine = url_res.read()    # 讀取html頁面
        print(webLine)              #輸出url頁面

g = get_url()
#由於之前使用了裝飾器，這裏不用next（）
g.send(‘http://www.baidu.com‘)

典型範例以及代碼解析：

實現linux中grep -rl ‘python‘ dir_path效果的代碼

# 想了半天覺得這個代碼好蠢，不放了。

列表生成式

範例：

l = [‘egg%s‘%i for i in range(100) if i >50]
print(l)

g = os.walk(c:\\scott)
l1 = [‘%s\\%s‘%(i[0],j)for i in g for j in i[-1]]

返回結果放在最前，列表生成的for運算放在中間，後面可加判斷語句
如果直接調用這個列表生成式的結果給一個函數進行運算，可以不用添加[]

生成器表達式

就是把列表生成的[]換成()
l = (‘egg%s‘%i for i in range(100) if i >50)

作業和練習

# 今日作業
# 有兩個列表，
# 分別存放來老男孩報名學習linux和python課程的學生名字

linux = [‘鋼彈‘, ‘小壁虎‘, ‘小虎比‘, ‘alex‘, ‘wupeiqi‘, ‘yuanhao‘]
python = [‘dragon‘, ‘鋼彈‘, ‘zhejiangF4‘, ‘小虎比‘]
# 問題一：得出既報名linux又報名python的學生列表
l1 = [x for x in linux if  x in python]
print (l1)
# 問題二：得出只報名linux，而沒有報名python的學生列表
l2 = [x for x in linux if x not in python]
print(l2)
# 問題三：得出只報名python，而沒有報名linux的學生列表
l3 = [x for x in python if x not in linux]
print(l3)


shares = {

    ‘IBM‘: 36.6,

    ‘lenovo‘: 27.3,

    ‘huawei‘: 40.3,

    ‘oldboy‘: 3.2,
    ‘ocean‘:20.1
}

# 問題一：得出股票價格大於30的股票名字列表
list_1 = [i for i in shares if shares[i]>30]
print(list_1)
# 問題二：求出所有股票的總價格
list_sum = sum (shares[i] for i in shares)
print(list_sum)


l = [10, 2, 3, 4, 5, 6, 7]

# 得到一個新列表l1，
# 新列表中每個元素是l中對應每個元素值的平方
l1 = [(x*x) for x in l]
print(l1)
# 過濾出l1中大於40的值，然後求和
l1_sum = sum(y for y in l1 if y >40)
print(l1_sum)

10.叠代器/生成器/協程函數/列表生成器