迭代器
迭代是訪問集合元素的一種方式,。迭代器是一個可以記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問,，直到所有的元素被訪問完結(jié)束,。迭代器只能往前不會后退。
1. 可迭代對象
我們已經(jīng)知道可以對list,、tuple,、str等類型的數(shù)據(jù)使用for...in...的循環(huán)語法從其中依次拿到數(shù)據(jù)進(jìn)行使用，我們把這樣的過程稱為遍歷,，也叫迭代,。
但是，是否所有的數(shù)據(jù)類型都可以放到for...in...的語句中,，然后讓for...in...每次從中取出一條數(shù)據(jù)供我們使用,，即供我們迭代嗎？
>>> for i in 100:
... print(i)
...
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>>
# int整型不是iterable,，即int整型不是可以迭代的
?
# 我們自定義一個容器MyList用來存放數(shù)據(jù),，可以通過add方法向其中添加數(shù)據(jù)
>>> class MyList(object):
... def __init__(self):
... self.container = []
... def add(self, item):
... self.container.append(item)
...
>>> mylist = MyList()
>>> mylist.add(1)
>>> mylist.add(2)
>>> mylist.add(3)
>>> for num in mylist:
... print(num)
...
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'MyList' object is not iterable
>>>
# MyList容器的對象也是不能迭代的
我們自定義了一個容器類型MyList，在將一個存放了多個數(shù)據(jù)的MyList對象放到for...in...的語句中,，發(fā)現(xiàn)for...in...并不能從中依次取出一條數(shù)據(jù)返回給我們,，也就說我們隨便封裝了一個可以存放多條數(shù)據(jù)的類型卻并不能被迭代使用。
我們把可以通過for...in...這類語句迭代讀取一條數(shù)據(jù)供我們使用的對象稱之為可迭代對象（Iterable）**,。
2. 如何判斷一個對象是否可以迭代
可以使用 isinstance() 判斷一個對象是否是 Iterable 對象：
In [50]: from collections import Iterable
?
In [51]: isinstance([], Iterable)
Out[51]: True
?
In [52]: isinstance({}, Iterable)
Out[52]: True
?
In [53]: isinstance('abc', Iterable)
Out[53]: True
?
In [54]: isinstance(mylist, Iterable)
Out[54]: False
?
In [55]: isinstance(100, Iterable)
Out[55]: False
3. 可迭代對象的本質(zhì)
我們分析對可迭代對象進(jìn)行迭代使用的過程,，發(fā)現(xiàn)每迭代一次（即在for...in...中每循環(huán)一次）都會返回對象中的下一條數(shù)據(jù)，一直向后讀取數(shù)據(jù)直到迭代了所有數(shù)據(jù)后結(jié)束,。那么,，在這個過程中就應(yīng)該有一個“人”去記錄每次訪問到了第幾條數(shù)據(jù)，以便每次迭代都可以返回下一條數(shù)據(jù),。我們把這個能幫助我們進(jìn)行數(shù)據(jù)迭代的“人”稱為迭代器(Iterator),。
可迭代對象的本質(zhì)就是可以向我們提供一個這樣的中間“人”即迭代器幫助我們對其進(jìn)行迭代遍歷使用。
可迭代對象通過__iter__方法向我們提供一個迭代器,，我們在迭代一個可迭代對象的時候,，實際上就是先獲取該對象提供的一個迭代器,，然后通過這個迭代器來依次獲取對象中的每一個數(shù)據(jù).
那么也就是說，一個具備了__iter__方法的對象,，就是一個可迭代對象,。
>>> class MyList(object):
... def __init__(self):
... self.container = []
... def add(self, item):
... self.container.append(item)
... def __iter__(self):
... """返回一個迭代器"""
... # 我們暫時忽略如何構(gòu)造一個迭代器對象
... pass
...
>>> mylist = MyList()
>>> from collections import Iterable
>>> isinstance(mylist, Iterable)
True
>>>
# 這回測試發(fā)現(xiàn)添加了__iter__方法的mylist對象已經(jīng)是一個可迭代對象了
4. iter()函數(shù)與next()函數(shù)
list、tuple等都是可迭代對象,，我們可以通過iter()函數(shù)獲取這些可迭代對象的迭代器,。然后我們可以對獲取到的迭代器不斷使用next()函數(shù)來獲取下一條數(shù)據(jù)。iter()函數(shù)實際上就是調(diào)用了可迭代對象的__iter__方法,。
>>> li = [11, 22, 33, 44, 55]
>>> li_iter = iter(li)
>>> next(li_iter)
11
>>> next(li_iter)
22
>>> next(li_iter)
33
>>> next(li_iter)
44
>>> next(li_iter)
55
>>> next(li_iter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
注意,，當(dāng)我們已經(jīng)迭代完最后一個數(shù)據(jù)之后，再次調(diào)用next()函數(shù)會拋出StopIteration的異常,，來告訴我們所有數(shù)據(jù)都已迭代完成,，不用再執(zhí)行next()函數(shù)了。**
5. 如何判斷一個對象是否是迭代器
可以使用 isinstance() 判斷一個對象是否是 Iterator 對象：
In [56]: from collections import Iterator
?
In [57]: isinstance([], Iterator)
Out[57]: False
?
In [58]: isinstance(iter([]), Iterator)
Out[58]: True
?
In [59]: isinstance(iter("abc"), Iterator)
Out[59]: True
6. 迭代器Iterator
通過上面的分析,，我們已經(jīng)知道,，迭代器是用來幫助我們記錄每次迭代訪問到的位置，當(dāng)我們對迭代器使用next()函數(shù)的時候,，迭代器會向我們返回它所記錄位置的下一個位置的數(shù)據(jù),。實際上，在使用next()函數(shù)的時候,，調(diào)用的就是迭代器對象的__next__方法（Python3中是對象的__next__方法,，Python2中是對象的next()方法）。所以,，我們要想構(gòu)造一個迭代器,，就要實現(xiàn)它的__next__方法。但這還不夠,，python要求迭代器本身也是可迭代的,，所以我們還要為迭代器實現(xiàn)__iter__方法，而__iter__方法要返回一個迭代器,，迭代器自身正是一個迭代器,，所以迭代器的__iter__方法返回自身即可。
一個實現(xiàn)了iter方法和next方法的對象,，就是迭代器,。
class MyList(object):
"""自定義的一個可迭代對象"""
def __init__(self):
self.items = []
?
def add(self, val):
self.items.append(val)
?
def __iter__(self):
myiterator = MyIterator(self)
return myiterator
?
class MyIterator(object):
"""自定義的供上面可迭代對象使用的一個迭代器"""
def __init__(self, mylist):
self.mylist = mylist
# current用來記錄當(dāng)前訪問到的位置
self.current = 0
?
def __next__(self):
if self.current < len(self.mylist.items):
item = self.mylist.items[self.current]
self.current += 1
return item
else:
raise StopIteration
?
def __iter__(self):
return self
if __name__ == '__main__':
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
mylist.add(4)
mylist.add(5)
for num in mylist:
print(num)
7. for...in...循環(huán)的本質(zhì)
for item in Iterable 循環(huán)的本質(zhì)就是先通過iter()函數(shù)獲取可迭代對象Iterable的迭代器，然后對獲取到的迭代器不斷調(diào)用next()方法來獲取下一個值并將其賦值給item,，當(dāng)遇到StopIteration的異常后循環(huán)結(jié)束,。
8. 迭代器的應(yīng)用場景
我們發(fā)現(xiàn)迭代器最核心的功能就是可以通過next()函數(shù)的調(diào)用來返回下一個數(shù)據(jù)值。如果每次返回的數(shù)據(jù)值不是在一個已有的數(shù)據(jù)集合中讀取的，而是通過程序按照一定的規(guī)律計算生成的,，那么也就意味著可以不用再依賴一個已有的數(shù)據(jù)集合,，也就是說不用再將所有要迭代的數(shù)據(jù)都一次性緩存下來供后續(xù)依次讀取，這樣可以節(jié)省大量的存儲（內(nèi)存）空間,。
舉個例子,，比如，數(shù)學(xué)中有個著名的斐波拉契數(shù)列（Fibonacci）,，數(shù)列中第一個數(shù)為0,，第二個數(shù)為1，其后的每一個數(shù)都可由前兩個數(shù)相加得到：
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
現(xiàn)在我們想要通過for...in...循環(huán)來遍歷迭代斐波那契數(shù)列中的前n個數(shù),。那么這個斐波那契數(shù)列我們就可以用迭代器來實現(xiàn)，每次迭代都通過數(shù)學(xué)計算來生成下一個數(shù),。
class FibIterator(object):
"""斐波那契數(shù)列迭代器"""
def __init__(self, n):
"""
:param n: int, 指明生成數(shù)列的前n個數(shù)
"""
self.n = n
# current用來保存當(dāng)前生成到數(shù)列中的第幾個數(shù)了
self.current = 0
# num1用來保存前前一個數(shù),，初始值為數(shù)列中的第一個數(shù)0
self.num1 = 0
# num2用來保存前一個數(shù)，初始值為數(shù)列中的第二個數(shù)1
self.num2 = 1
?
def __next__(self):
"""被next()函數(shù)調(diào)用來獲取下一個數(shù)"""
if self.current < self.n:
num = self.num1
self.num1, self.num2 = self.num2, self.num1+self.num2
self.current += 1
return num
else:
raise StopIteration
?
def __iter__(self):
"""迭代器的__iter__返回自身即可"""
return self
?
?
if __name__ == '__main__':
fib = FibIterator(10)
for num in fib:
print(num, end=" ")
9. 并不是只有for循環(huán)能接收可迭代對象
除了for循環(huán)能接收可迭代對象,，list,、tuple等也能接收。
li = list(FibIterator(15))
print(li)
tp = tuple(FibIterator(6))
print(tp)
|
