（點選上方公眾號，可快速關註一起學Python）

作者：浪子燕青       連結：

http://www.langzi.fun/迭代器與生成器.html

 

迭代器與可迭代物件

概念

迭代器：是訪問資料集合內元素的一種方式，一般用來遍歷資料，但是他不能像串列一樣使用下標來獲取資料，也就是說迭代器是不能傳回的。

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. 一般由可迭代物件變迭代器物件

可迭代物件

可迭代物件每次使用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 
    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)

傳回結果：

 

1
2
3

 

這個時候是不能再用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))

傳回結果：

 

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)

傳回結果：

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)