一、迭代器

定義：

對於list、string、tuple、dict等這些容器物件,使用for迴圈遍歷是很方便的。在後臺for語句對容器物件呼叫iter()函式。iter()是python內建函式。 
iter()函式會返回一個定義了next()方法的迭代器物件，它在容器中逐個訪問容器內的元素。next()也是python內建函式。在沒有後續元素時，next()會丟擲一個StopIteration異常，通知for語句迴圈結束。

迭代器是用來幫助我們記錄每次迭代訪問到的位置，當我們對迭代器使用next()函式的時候，迭代器會向我們返回它所記錄位置的下一個位置的資料。實際上，在使用next()函式的時候，呼叫的就是迭代器物件的_next_方法

（Python3中是物件的_next_方法，Python2中是物件的next()方法）。所以，我們要想構造一個迭代器，就要實現它的_next_方法。

但這還不夠，python要求迭代器本身也是可迭代的，所以我們還要為迭代器實現_iter_方法，而_iter_方法要返回一個迭代器，迭代器自身正是一個迭代器，所以迭代器的_iter_方法返回自身self即可。

一些術語的解釋：

1，迭代器協議：物件需要提供next()方法，它要麼返回迭代中的下一項，要麼就引起一個StopIteration異常，以終止迭代

2，可迭代物件：實現了迭代器協議物件。list、tuple、dict都是Iterable（可迭代物件），但不是Iterator（迭代器物件）。但可以使用內建函式iter()，把這些都變成Iterable（可迭代器物件）。

3，for item in Iterable 迴圈的本質就是先通過iter()函式獲取可迭代物件Iterable的迭代器，然後對獲取到的迭代器不斷呼叫next()方法來獲取下一個值並將其賦值給item，當遇到StopIteration的異常後迴圈結束

Python自帶容器物件案例：

# 隨便定義一個list
listArray=[1,2,3]
# 使用iter()函式
iterName=iter(listArray)
print(iterName)
# 結果如下：是一個列表list的迭代器
# <list_iterator object at 0x0000017B0D984278>

print(next(iterName))
print(next(iterName))
print(next(iterName))
print(next(iterName))#沒有迭代到下一個元素，直接丟擲異常
# 1
# 2
# 3
# Traceback (most recent call last):
#   File "Test07.py", line 32, in <module>
# StopIteration！
 

Python中一個實現了_iter_方法和_next_方法的類物件，就是迭代器，如下案例是計算菲波那切數列的案例

class Fib(object):
    def __init__(self, max):
        super(Fib, self).__init__()
        self.max = max
    def __iter__(self):
        self.a = 0
        self.b = 1
        return self
    def __next__(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib
# 定義一個main函式，迴圈遍歷每一個菲波那切數
def main():
    # 100以內的數
    fib = Fib(100)
    for i in fib:
        print(i)
# 測試
if __name__ == '__main__':
    main()

解釋說明：

在本類的實現中，定義了一個_iter_(self)方法，這個方法是在for迴圈遍歷時被iter()呼叫，返回一個迭代器。因為在遍歷的時候，是直接呼叫的python內建函式iter()，由iter()通過呼叫_iter_(self)獲得物件的迭代器。有了迭代器，就可以逐個遍歷元素了。而逐個遍歷的時候，也是使用內建的next(）函式通過呼叫物件的_next_(self)方法對迭代器物件進行遍歷。所以要實現_iter_(self)和_next_(self)這兩個方法。

而且因為實現了_next_(self)方法，所以在實現_iter_(self)的時候，直接返回self就可以。

總結一句話就是： 
在迴圈遍歷自定義容器物件時,會使用python內建函式iter()呼叫遍歷物件的_iter_(self)獲得一個迭代器,之後再迴圈對這個迭代器使用next()呼叫迭代器物件的_next_(self)。

注意點：_iter_(self)只會被呼叫一次,而_next_(self)會被呼叫 n 次，直到出現StopIteration異常。

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化兩個計數器a，b
    def __iter__(self):
        return self # 例項本身就是迭代物件，故返回自己
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 計算下一個值
        if self.a > 100000: # 退出迴圈的條件
            raise StopIteration();
        return self.a # 返回下一個值

IJCNLP的例子：

注意：這個例子中沒有__next(self)__，而是使用了yield.

這樣產生的是一個生成器。所以更像下面談到的生成器的用法。

class FlashcardSentences(object):
    def __init__(self, num_list):
        self.num_list = num_list
    def __iter__(self):
        for line in self.num_list:
            yield line
            
a=FlashcardSentences([3,2,3,4,5])
'''注意：這是生成器物件'''
print(iter(a))
#<generator object __iter__ at 0x000002A7AC4998E0>
for i in a:
    print(i)
//////////////////////////////////////////////////////////////////////////////////
class FlashcardSentences(object):
    def __init__(self, filename):
        self.filename = filename
    def __iter__(self):
        for line in open(self.filename, "rb"):
            line = line.strip()
            line = line.decode("utf8").encode("ascii", "ignore")
            _, question, answer = line.split("\t")
            qwords = nltk.word_tokenize(question)
            awords = nltk.word_tokenize(answer)
            yield qwords + awords

二、生成器

作用：

迭代器是一個物件，而生成器是一個函式，迭代器和生成器是python中兩個非常強大的特性，編寫程式時你可以不使用生成器達到同樣的效果，但是生成器讓你的程式更加pythonic。

建立生成器只要在函式中加入yield語句即可。函式中每次使用yield產生一個值，函式就返回該值，然後停止執行，等待被啟用，被啟用後繼續在原來的位置執行。

也就是：每到yield執行完就暫停。

下邊的例子實現了同樣的功能： 

注意事項：

生成器是隻能遍歷一次的。

生成器是一類特殊的迭代器。

例子：

#!/usr/bin/env python
#coding=utf-8
def fib():
    a,b = 0,1
    while 1:
        a,b = b,a+b
        yield a
for f in fib():
    if f < 10000:
        print f
    else:
        break

注意下面的例子：

f=Fib(10)會產生一個生成器，這裡不需要使用iter()函式。 

def Fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return '親！沒有資料了...'
# 呼叫方法，生成出10個數來
f=Fib(10)
# 使用一個迴圈捕獲最後return 返回的值，儲存在異常StopIteration的value中
while  True:
    try:
        x=next(f)
        print("f:",x)
    except StopIteration as e:
        print("生成器最後的返回值是：",e.value)
        break

def createGenerator():
    mylist = range(3)
    for i in mylist:
        yield i*i

mygenerator = createGenerator() # 建立生成器
print(mygenerator) # mygenerator is an object!
#<generator object createGenerator at 0x000002A7AC499B48>
for i in mygenerator:
    print(i)

在CNN情感分析中的例子：

def batch_iter(data, batch_size, num_epochs):
    """
    Generates a batch iterator for a dataset.
    """
    data = np.array(data)
    data_size = len(data)
    num_batches_per_epoch = int(len(data)/batch_size) + 1
    for epoch in range(num_epochs):
        # Shuffle the data at each epoch
        shuffle_indices = np.random.permutation(np.arange(data_size))
        shuffled_data = data[shuffle_indices]
        for batch_num in range(num_batches_per_epoch): #batch_num表示第幾批
            start_index = batch_num * batch_size
            end_index = min((batch_num + 1) * batch_size, data_size)
            yield shuffled_data[start_index:end_index]