概念

叠代器：是訪問數據集合內元素的一種方式，一般用來遍歷數據，但是他不能像列表一樣使用下標來獲取數據，也就是說叠代器是不能返回的。

1. Iterator：叠代器對象，必須要實現 next 魔法函數

2. Iterable：可叠代對象，繼承 Iterator，必須要實現 iter 魔法函數

比如：

from collections import Iterable,Iterator
a = [1,2,3]
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))

返回結果：

False
True

在 Pycharm 中使用 alt+b 進去 list 的源碼中可以看到，在 list 類中有 iter 魔法函數，也就是說只要實現了 iter 魔法函數，那麽這個對象就是可叠代對象。

上面的例子中 a 是一個列表，也是一個可叠代對象，那麽如何才能讓這個 a 變成叠代器呢？使用 iter() 即可。

from collections import Iterable,Iterator
a = [1,2,3]
a = iter(a)
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
print(next(a))
print(‘----‘)
for x in a:
    print(x)

返回結果：

True
True
1
----
2
3

可以看到現在 a 是可叠代對象又是一個叠代器，說明列表 a 中有 iter 方法，該方法返回的是叠代器，這個時候使用 next 就可以獲取 a 的下一個值，但是要記住叠代器中的數值只能被獲取一次。

梳理叠代器 (Iterator) 與可叠代對象 (Iterable) 的區別：

1. 可叠代對象：繼承叠代器對象，可以用 for 循環(說明實現了 iter 方法)

2. 叠代器對象：可以用 next 獲取下一個值(說明實現了 next 方法)，但是每個值只能獲取一次，單純的叠代器沒有實現 iter 魔法函數，所以不能使用 for 循環

3. 只要可以用作 for 循環的都是可叠代對象

4. 只要可以用 next() 函數的都是叠代器對象

5. 列表,字典,字符串是可叠代對象但是不是叠代器對象，如果想變成叠代器對象可以使用 iter() 進行轉換

6. Python 的 for 循環本質上是使用 next() 進行不斷調用，for 循環的是可叠代對象，可叠代對象中有 iter 魔法函數，可叠代對象繼承叠代器對象，叠代器對象中有 next 魔法函數
7. 一般由可叠代對象變叠代器對象

大家在學python的時候肯定會遇到很多難題，以及對於新技術的追求，這裏推薦一下我們的Python學習扣qun：784758214，這裏是python學習者聚集地！！同時，自己是一名高級python開發工程師，從基礎的python腳本到web開發、爬蟲、django、數據挖掘等，零基礎到項目實戰的資料都有整理。送給每一位python的小夥伴！每日分享一些學習的方法和需要註意的小細節

可叠代對象

可叠代對象每次使用 for 循環一個數組的時候，本質上會從類中嘗試調用 iter 魔法函數，如果類中有 iter 魔法函數的話，會優先調用iter魔法函數，當然這裏切記 iter 方法必須要返回一個可以叠代的對象，不然就會報錯。

如果沒有定義 iter 魔法函數的話，會創建一個默認的叠代器，該叠代器調用 getitem 魔法函數，如果你沒有定義 iter 和 getitem 兩個魔法函數的話，該類型就不是可叠代對象，就會報錯。

比如：

class s:
    def __init__(self,x):
        self.x = x
    def __iter__(self):
        return iter(self.x)
        # 這裏必須要返回一個可以叠代的對象
    # def __getitem__(self, item):
    #     return self.x[item]
# iter和getitem其中必須要實現一個
a = s(‘123‘)
# 這裏的a就是可叠代對象
# 這裏不能調用next(a)方法，因為沒有定義
for x in a:
    print(x)

這裏把註釋符去掉返回結果也是一樣的，返回結果：

1
2
3

叠代器對象

一開始提起，iter 搭配 Iterable 做可叠代對象，next 搭配 Iterator 做叠代器。next() 接受一個叠代器對象，作用是獲取叠代器對象的下一個值，叠代器是用來做叠代的，只會在需要的時候產生數據。

和可叠代對象不同，可叠代對象一開始是把所有的列表放在一個變量中，然後用 getitem 方法不斷的返回數值，getitem 中的 item 就是索引值。

但是 next 方法並沒有索引值，所以需要自己維護一個索引值，方便獲取下一個變量的位置。

class s:
    def __init__(self,x):
        self.x = x
        # 獲取傳入的對象
        self.index = 0
        # 維護索引值
    def __next__(self):
        try:
            result = self.x[self.index]
            # 獲取傳入對象的值
        except IndexError:
            # 如果索引值錯誤
            raise StopIteration
        # 拋出停止叠代
        self.index += 1
        # 索引值+1，用來獲取傳入對象的下一個值
        return result
        # 返回傳入對象的值

a = s([1,2,3])
print(next(a))
print(‘----------‘)
for x in a:
# 類中並沒有iter或者getitem魔法函數，不能用for循環，會報錯
    print(x)

返回結果：

Traceback (most recent call last):
1
----------
  File "C:/CODE/Python進階知識/叠代協議/叠代器.py", line 34, in <module>
    for x in a:
TypeError: ‘s‘ object is not iterable

上面一個就是完整的叠代器對象，他是根據自身的索引值來獲取傳入對象的下一個值，並不是像可叠代對象直接把傳入對象讀取到內存中，所以對於一些很大的文件讀取的時候，可以一行一行的讀取內容，而不是把文件的所有內容讀取到內存中。

這個類是叠代器對象，那麽如何才能讓他能夠使用 for 循環呢？那就讓他變成可叠代對象，只需要在類中加上 iter 魔法函數即可。

class s:
    def __init__(self,x):
        self.x = x
        # 獲取傳入的對象
        self.index = 0
        # 維護索引值
    def __next__(self):
        try:
            result = self.x[self.index]
            # 獲取傳入對象的值
        except IndexError:
            # 如果索引值錯誤
            raise StopIteration
        # 拋出停止叠代
        self.index += 1
        # 索引值+1，用來獲取傳入對象的下一個值
        return result
        # 返回傳入對象的值
    def __iter__(self):
        return self
a = s([1,2,3])
print(next(a))
print(‘----------‘)
for x in a:
    print(x)

返回結果：

1
----------
2
3

可以看到這個時候運行成功，但是這個對象還是屬於叠代器對象，因為在 next 獲取下一個值會報錯。

知識整理

根據上面的代碼提示，得到規律：

1. iter 讓類變成可叠代對象，next 讓類變成叠代器(要維護索引值)。

2. 可叠代對象可以用 for 循環，叠代器可以用next獲取下一個值。

3. 叠代器如果想要變成可叠代對象用 for 循環，就要在叠代器內部加上 iter 魔法函數

4. 可叠代對象如果想要能用 next 魔法函數，使用自身類中的 iter() 方法即可變成叠代器對象

class s:
    def __init__(self,x):
        self.x = x
        self.index = 0
    def __next__(self):
        try:
            result = self.x[self.index]
        except IndexError:
            raise StopIteration
        self.index += 1
        return result

class b:
    def __init__(self,x):
        self.x = x
    def __iter__(self):
        return s(self.x)
a = b([1,2,3])

for x in a:
    print(x)

返回結果：

123

這個時候是不能再用 next 方法了，應為類 b 是一個可叠代對象，並非叠代器，這個時候不能用 next 方法，但是可以讓類 b 繼承類 s，這樣就能用 next() 方法獲取下一個值，但是你的類 b 中要存在索引值，不然會報錯，如下代碼:

class s:
    def __init__(self,x):
        self.x = x
        # 獲取傳入的對象
        self.index = 0
        # 維護索引值
    def __next__(self):
        try:
            result = self.x[self.index]
            # 獲取傳入對象的值
        except IndexError:
            # 如果索引值錯誤
            raise StopIteration
        # 拋出停止叠代
        self.index += 1
        # 索引值+1，用來獲取傳入對象的下一個值
        return result
        # 返回傳入對象的值
    # def __iter__(self):
    #     return self
class b(s):
    def __init__(self,x):
        self.x = x
        self.index = 0
    def __iter__(self):
        return s(self.x)
a = b([1,2,3])

print(next(a))
print(next(a))

返回結果：

1
2

可以這麽做，但是沒必要，因為這樣違反了設計原則。

叠代器的設計模式

叠代器模式：提供一種方法順序訪問一個聚合對象中的各種元素，而又不暴露該對象的內部
表示。

叠代器的設計模式是一種經典的設計模式，根據叠代器的特性(根據索引值讀取下一個內容，不一次性讀取大量數據到內存)不建議將 next 和 iter 都寫在一個類中去實現。

新建一個叠代器，用叠代器維護索引值，返回根據索引值獲取對象的數值，新建另一個可叠代對象，使用 iter 方法方便的循環叠代器的返回值。

生成器

生成器：函數中只要有 yield，這個函數就會變成生成器。每次運行到 yield 的時候，函數會暫停，並且保存當前的運行狀態，返回返回當前的數值，並在下一次執行 next 方法的時候，又從當前位置繼續往下走。

簡單用法

舉個例子：

def gen():
    yield 1
    # 返回一個對象，這個對象的值是1
def ret():
    return 1
    # 返回一個數字1
g = gen()
r = ret()
print(g,r)
print(next(g))

返回結果：

<generator object gen at 0x000001487FDA2D58> 1
1

可以看到return是直接返回數值 1，yield 是返回的一個生成器對象，這個對象的值是 1，使用 next(g) 或者 for x in g:print x 都是可以獲取到他的內容的，這個對象是在 python 編譯字節碼的時候就產生。

def gen():
    yield 1
    yield 11
    yield 111
    yield 1111
    yield 11111
    yield 111111
    # 返回一個對象，這個對象內的值是1和11,111...
def ret():
    return 1
    return 3
    # 第二個return是無效的
g = gen()
r = ret()
print(g,r)
print(next(g))
for x in g:
    print(x)

返回結果：

<generator object gen at 0x000002885FE32D58> 1
1
11
111
1111
11111
111111

就像叠代器的特性一樣，獲取過一遍的值是沒法再獲取一次的，並且不是那種一次把所有的結果求出放在內存或者說不是一次性讀取所有的內容放在內存中。

梳理特性：

1. 使用 yield 的函數都是生成器函數

2. 可以使用 for 循環獲取值，也可以使用 next 獲取生成器函數的值

原理

函數工作原理：函數的調用滿足“後進先出”的原則，也就是說，最後被調用的函數應該第一個返回，函數的遞歸調用就是一個經典的例子。顯然，內存中以“後進先出”方式處理數據的棧段是最適合用於實現函數調用的載體，在編譯型程序語言中，函數被調用後，函數的參數，返回地址，寄存器值等數據會被壓入棧，待函數體執行完畢，將上述數據彈出棧。這也意味著，一個被調用的函數一旦執行完畢，它的生命周期就結束了。

Python 解釋器運行的時候，會用 C 語言當中的 PyEval_EvalFramEx 函數創建一個棧幀，所有的棧幀都是分配再堆內存上，如果不主動釋放就會一直在裏面。

Python 的堆棧幀是分配在堆內存中的，理解這一點非常重要！Python 解釋器是個普通的 C 程序，所以它的堆棧幀就是普通的堆棧。但是它操作的 Python 堆棧幀是在堆上的。除了其他驚喜之外，這意味著 Python 的堆棧幀可以在它的調用之外存活。(FIXME: 可以在它調用結束後存活)，這個就是生成器的核心原理實現。

Python 腳本都會被 python.exe 編譯成字節碼的形式，然後 python.exe 再執行這些字節碼，使用 dis 即可查看函數對象的字節碼對象。

import dis
# 查看函數程序字節碼
a = ‘langzi‘
print(dis.dis(a))
print(‘-‘*20)
def sb(admin):
    print(admin)
print(dis.dis(sb))

返回結果：

  1           0 LOAD_NAME                0 (langzi)
# 加載名字 為langzi
              2 RETURN_VALUE
# 返回值
None
--------------------
 15           0 LOAD_GLOBAL              0 (print)
# 加載一個print函數
              2 LOAD_FAST                0 (admin)
# 加載傳遞參數為admin
              4 CALL_FUNCTION            1
# 調用這個函數
              6 POP_TOP
# 從棧的頂端把元素移除出來
              8 LOAD_CONST               0 (None)
# 因為該函數沒有返回任何值，所以加載的值是none
             10 RETURN_VALUE
# 最後把load_const的值返回(個人理解)
None

代碼函數運行的時候，Python 將代碼編譯成字節碼，當函數存在 yield 的時候，Python 會將這個函數標記成生成器，當調用這個函數的時候，會返回生成器對象，調用這個生成器對象後C語言中寫的函數會記錄上次代碼執行到的位置和變量。

在 C 語言中的 PyGenObject 中有兩個值，gi_frame (存儲上次代碼執行到的位置 f_lasti 的上次代碼執行到的變量 f_locals),gi_code (存儲代碼)，使用 dis 也可以獲取到上次代碼執行的位置和值。

舉個例子：

import dis
def gen():
    yield 1
    yield 2
    return 666

g = gen()
# g是生成器對象
print(dis.dis(g))
print(‘*‘*10)
print(g.gi_frame.f_lasti)
# 這裏還沒有執行，返回的位置是-1
print(g.gi_frame.f_locals)
# 這裏還沒有執行，返回的對象是{}
next(g)
print(‘*‘*10)
print(g.gi_frame.f_lasti)
print(g.gi_frame.f_locals)

返回結果：

 11           0 LOAD_CONST               1 (1)
# 加載值為1
              2 YIELD_VALUE
              4 POP_TOP

 12           6 LOAD_CONST               2 (2)
              8 YIELD_VALUE
             10 POP_TOP

 13          12 LOAD_CONST               3 (666)
             14 RETURN_VALUE
None
**********
-1
# 因為還沒有執行，所以獲取的行數為 -1
{}
**********
2
# 這裏開始執行了第一次，獲取的行數是2，2對應2 YIELD_VALUE就是前面加載的數值1
{}
# g.gi_frame.f_locals 是局部變量，你都沒定義那麽獲取的結果自然是{}，你只需在代碼中加上user=‘admin‘，這裏的{}就會改變。

生成器可以在任何時候被任何函數恢復執行，因為它的棧幀實際上不在棧上而是在堆上。生成器在調用調用層次結構中的位置不是固定的，也不需要遵循常規函數執行時遵循的先進後出順序。因為這些特性，生成器不僅能用於生成可叠代對象，還可以用於實現多任務協作。

就是說只要拿到了這個生成器對象，就能對這個生成器對象進行控制，比如繼續執行暫停等待，這個就是協程能夠執行的理論原理。

應用場景

讀取文件，使用 open(‘xxx’).read(2019)// 打開一個文件，每次讀取 2019 個偏移量。文件 a.txt 是一行文字，但是特別長，這一行文字根據|符號分開，如何讀取？

寫入文件代碼：

# -*- coding:utf-8 -*-
import random
import threading
import string
import time
t1 = time.time()
def write(x):
    with open(‘a.txt‘,‘a+‘)as a:
        a.write(x + ‘||‘)

def run():
    for x in range(10000000):
        strs = str(random.randint(1000,2000)) +random.choice(string.ascii_letters)*10
        write(strs)
for x in range(10):
    t = threading.Thread(target=run)
    t.start()
t2 = time.time()
print(t2 - t1)

讀取文件代碼：

# -*- coding:utf-8 -*-
def readbooks(f, newline):
    # f為傳入的文件名，newline為分隔符
    buf = ""
    # 緩存，處理已經讀出來的數據量
    while 1:
        while newline in buf:
            # 緩存中的數據是否存在分隔符
            pos = buf.index(newline)
            # 如果存在就找到字符的位置,比如0或者1或者2
            yield buf[:pos]
            # 暫停函數，返回緩存中的從頭到字符的位置
            buf = buf[pos + len(newline):]
            # 緩存變成了，字符的位置到末尾
        chunk = f.read(2010 * 10)
        # 讀取2010*10的字符
        if not chunk:
            # 已經讀取到了文件結尾
            yield buf
            break
        buf += chunk
        # 加到緩存
 with open(‘a.txt‘,‘r‘)as f:
     for line in readbooks(f,‘||‘):
         print(line)

幹貨推薦：看過介紹 Python 叠代器和生成器最易懂、最全面的文章