文章目錄

• Python的for迴圈
• for迴圈示例
• List 列表迴圈
• dict 字典迴圈
• 列表生成式
• 生成器
• 列表式生成器
• 函式式生成器
• 生成器式生產者消費者模型
• 迭代器
• 什麼是迭代器
• 再論for迴圈
• 迭代器物件的使用

Python的for迴圈、迭代器、生成器有必要記錄一下，學習Python的生成器時候，頭一次見到函式可以這麼寫，後來瞭解到貌似用yield關鍵字後，函式不再是函數了，執行方式也很有意思，因此有必要詳細記錄一下。貌似用yield做生成器後可以實現偽多執行緒。既然要寫生成器，就要把來龍去脈寫清楚，讓自己理解的更加透徹；這三者自我感覺是相關聯的，這篇文章就把它們說清楚。

Python的for迴圈

Python for迴圈可以遍歷任何可序列的物件，格式是：for … in …

• 第一個 … 中表示迴圈的變數，變數可以有多個，只要是後面物件中可以序列的變數就行，但是一般最多就2個，迄今為止我還沒有看到3個的
• 第二個 … 中表示迴圈的物件，要求此物件可以序列化
  Python的for迴圈抽象程度要高於C的for迴圈，因為Python的for迴圈不僅可以用在list或tuple上，還可以作用在其他可迭代物件上。list這種資料型別雖然有下標，但很多其他資料型別是沒有下標的，但是隻要是可迭代物件，無論有無下標，都可以用for迴圈迭代。

for迴圈示例

List 列表迴圈

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
#執行這段程式碼，會依次列印names的每一個元素：
Michael
Bob
Tracy

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)
#如果要計算1-100的整數之和，從1寫到100有點困難，Python提供一個range()函式，可以生成一個整數序列
sum = 0
for x in range(100
 
):
    sum = sum + x
print(sum)

dict 字典迴圈

Python字典，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）儲存，具有極快的查詢速度。
這種key-value儲存方式，在放進去的時候，必須根據key算出value的存放位置，這樣取的時候才能根據key直接拿到value；
請務必注意，dict內部存放的順序和key放入的順序是沒有關係的，雖然我們迴圈字典的時候，貌似是按照字典寫入順序輸出的，這是因為Python3在內部為我們做了優化，Python2 可就不好說了，尤其是當字典儲存大量資料時。
和list比較，dict有以下幾個特點：

查詢和插入的速度極快，不會隨著key的增加而變慢；
需要佔用大量的記憶體，記憶體浪費多。

而list相反：

查詢和插入的時間隨著元素的增加而增加；
佔用空間小，浪費記憶體很少。

所以，dict是用空間來換取時間的一種方法。
dict可以用在需要高速查詢的很多地方，在Python程式碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變物件。
這是因為dict根據key來計算value的儲存位置，如果每次計算相同的key得出的結果不同，那dict內部就完全混亂了。這個通過key計算位置的演算法稱為雜湊演算法（Hash）。
要保證hash的正確性，作為key的物件就不能變。在Python中，字串、整數等都是不可變的，因此，可以放心地作為key。而list是可變的，就不能作為key

#迴圈遍歷字典的key
>>> a={'a': '1', 'b': '2', 'c': '3'}
>>> for key in a:
       print(key+':'+a[key])
a:1
b:2
c:3
>>> for key in a.keys():
       print(key+':'+a[key])
a:1
b:2
c:3

#迴圈遍歷字典的value
>>> for value in a.values():
       print(value)
1
2
3
#迴圈遍歷字典項
>>> a={'a': '1', 'b': '2', 'c': '3'}
>>> for kv in a.items():
...        print(kv)
... 
('a', '1')
('c', '3')
('b', '2')

#迴圈遍歷字典key-value
>>> for key,value in a.items():
       print(key+':'+value)
a:1
b:2
c:3
>>> for (key,value) in a.items():
       print(key+':'+value)
a:1
b:2
c:3

列表生成式

列表生成式主要使用for迴圈來生成一個列表，for迴圈包含列表中每一個元素的生成規則

# 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎麼做？
>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 採用列表生成式
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# for迴圈後面還可以加上if判斷，這樣我們就可以篩選出僅偶數的平方
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

# 使用兩層迴圈，可以生成全排列
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

>>> import os 
>>> [d for d in os.listdir('.')] # os.listdir可以列出檔案和目錄
['.ssh', '.Trash', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Movies', 'Pictures']

# 列表生成式也可以使用兩個變數來生成list
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

# 把一個list中所有的字串變成小寫
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器

通過列表生成式，直接建立一個列表；但是受到記憶體限制，列表容量肯定是有限的；建立一個包含100萬個元素的列表，估計還沒有這麼大記憶體裝置，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。
所以，如果列表元素可以按照某種演算法推算出來，那我們是否可以在迴圈的過程中不斷推算出後續的元素呢？這樣就不必建立完整的list，從而節省大量的空間。在Python中，這種一邊迴圈一邊計算的機制，稱為生成器：generator。
我學到的有兩種生成器：列表是生成器、函式式生成器

列表式生成器

要建立一個列表式生成器generator，很簡單，只要把一個列表生成式的[]改成()，就建立了一個generator

>>> L = [x * x for x in range(5)]
>>> L
[0, 1, 4, 9, 16, 25]
>>> g = (x * x for x in range(5))
>>> 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)
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
# 所以，建立了一個generator後，基本上永遠不會呼叫next()，而是通過for迴圈來迭代它，並且不需要關心StopIteration的錯誤。

函式式生成器

如果推算的演算法比較複雜，用類似列表生成式的for迴圈無法實現的時候，還可以用函式來實現。
著名的斐波拉契數列（Fibonacci），就無法用for迴圈列表生成式實現，除第一個和第二個數外，任意一個數都可由前兩個數相加得到，可用函式式生成器實現：

# 波拉契數列用列表生成式寫不出來，但是用函式把它打印出來卻很容易：
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]
# 不必顯式寫出臨時變數t就可以賦值

可以看出，fib函式實際上是定義了斐波拉契數列的推算規則，從第一個元素開始，推算出後續任意的元素，這種邏輯其實非常類似generator。
上面的函式和generator僅一步之遙。要把fib函式變成generator，只需要把print(b)改為yield b就可以了

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
# 定義g函式式enerator的方法：如果一個函式定義中包含yield關鍵字，那麼這個函式就不再是一個普通函式，而是一個generator
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

這裡，最難理解的就是generator和函式的執行流程不一樣。函式是順序執行，遇到return語句或者最後一行函式語句就返回。而變成generator的函式，在每次呼叫next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
想想，Python直譯器是怎麼做到的
舉個簡單的例子，定義一個generator，依次返回數字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
# 呼叫該generator時，首先要生成一個generator物件，然後用next()函式不斷獲得下一個返回值：
>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

可以看到，odd不是普通函式，而是generator，在執行過程中，遇到yield就中斷，下次又繼續執行。執行3次yield後，已經沒有yield可以執行了，所以，第4次呼叫next(o)就報錯。
回到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

生成器式生產者消費者模型

生成器yiled關鍵字即可以有返回值，還可以接收值；利用這個特性，可以做到單執行緒下，實現並行效果
生成器物件的方法：

• send()：恢復生成器在上一次yiled關鍵字暫停時，繼續執行，同時yiled關鍵字還可以接收send函式傳送的引數
• __next()__：生成器繼續執行到下一次的yiled關鍵字處，暫停

import time
def consumer(name):
    print("%s consumer is ready!" %name)
    while True:
       p = yield
       print("product [%s] is comming,received by [%s]!" %(p, name))
       
def producer(name, g_consumer):  
    g_consumer.__next__()
    print("producer %s is ready!"%name)
    for i in range(5):
        time.sleep(1)
        print("producer %s get new product %s"%(name, i))
        g_consumer.send(i)
        
c1 = consumer('A')
producer("luke",c1)
'''
程式執行結果：
A consumer is ready!
producer luke is ready!
producer luke get new product 0
product [0] is comming,received by [A]!
producer luke get new product 1
product [1] is comming,received by [A]!
producer luke get new product 2
product [2] is comming,received by [A]!
producer luke get new product 3
product [3] is comming,received by [A]!
producer luke get new product 4
product [4] is comming,received by [A]!
'''

迭代器

什麼是迭代器

迭代是一個重複的過程，每次重複即一次迭代，並且每次迭代的結果都是下一次迭代的初始值，

• 為何要有迭代器：對於序列型別：字串、列表、元組，我們可以使用索引的方式迭代取出其包含的元素；但對於字典、集合、檔案等型別是沒有索引的，若還想取出其內部包含的元素，則必須找出一種不依賴於索引的迭代方式，這就是迭代器
• 什麼是可迭代物件：可迭代物件指的是內建有__iter__()方法的物件，即obj.__iter__()
• 什麼是迭代器物件：可迭代物件執行obj.__iter__()得到的結果就是迭代器物件；而迭代器物件指的是即內建有__iter__又內建有__next__方法的物件。
• 檔案型別是迭代器物件
  open('a.txt').__iter__()
open('a.txt').__next__()

優點：

• 提供一種統一的、不依賴於索引的迭代方式
• 惰性計算，節省記憶體

缺點：

• 無法獲取長度（只有在next完畢才知道到底有幾個值）
• 一次性的，只能往後走，不能往前退

再論for迴圈

for迴圈的工作原理：

• 1、執行in後物件的dic.__iter__()方法，得到一個迭代器物件iter_dic
• 2、執行next(iter_dic)，將得到的值賦值給k,然後執行迴圈體程式碼
• 3、重複過程2，直到捕捉到異常StopIteration，結束迴圈

可以直接作用於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

迭代器物件的使用

dic={'a':1,'b':2,'c':3}
iter_dic=dic.__iter__() 
#得到迭代器物件，迭代器物件即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身
iter_dic.__iter__() is iter_dic #True

print(iter_dic.__next__()) #等同於next(iter_dic)
print(iter_dic.__next__()) #等同於next(iter_dic)
print(iter_dic.__next__()) #等同於next(iter_dic)
# print(iter_dic.__next__()) #丟擲異常StopIteration，或者說結束標誌

#有了迭代器，我們就可以不依賴索引迭代取值了
iter_dic=dic.__iter__()
while 1:
    try:
        k=next(iter_dic)
        print(dic[k])
    except StopIteration:
        break
#這麼寫太麻煩了，需要我們自己捕捉異常，控制next，for迴圈這麼牛逼，幹嘛不用for迴圈呢
#基於for迴圈，我們可以完全不再依賴索引去取值了
dic={'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])

由for迴圈開始，繞了一圈又回到了for迴圈，中間引申出列表生成式、生成器、迭代器，它們之間的關係我已經寫完了，感覺自己又進步一點了，再接再厲。