迭代器

迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

可迭代对象

在Python中，可以通过for … in …方式进行遍历内部元素的，称之为可迭代对象，就比如list,字典，元祖等类型

如何判断一个对象是否是可迭代对象

可以通过isinstance函数来判定，代码示例:

1
2
3
4
from collection import Iterable

isinstance([],Iterable)
isinstance({},Iterable)

注意上边的[] {}返回的是一个空的列表 字典对象，可能这种写法比较奇怪
通过isinstance的返回值，是True的话就是可迭代对象，是False就是不可迭代的

可迭代对象的本质

我们分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for…in…中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。
可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。

可迭代对象通过iter方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.

那么也就是说，一个具备了iter方法的对象，就是一个可迭代对象。
下面代码实现自己的列表:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from collections import Iterable
class MyList(object):
    def __init__(self):
        self.inner_list = list()

    def __iter__(self):
        pass

    def add(self,val):
        self.inner_list.append(val)

if __name__ == "__main__":
    ml = MyList()
    ml.add(1)
    ml.add(2)
    ml.add(3)
    print(isinstance(ml,Iterable))

运行结果:

1
True

说明有了iter方法之后，就是一个可迭代对象了

iter()函数和next()函数

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的iter方法。代码示例:

1
2
3
4
5
6
7
8
li = [1,2,3,4,5]

it = iter(li)
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))

运行结果:

1
2
3
4
5
1
2
3
4
5

如何判断一个对象是否是迭代器

可以使用instance函数判断

1
2
3
4
from collections import Iterator

print("list is Iterator?",isinstance([],Iterator))
print("iter(list) is Iterator?",isinstance(iter([]),Iterator))

运行结果:

1
2
list is Iterator? False
iter(list) is Iterator? True

迭代器Iterator

通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的next方法（Python3中是对象的next方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的next方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现iter方法，而iter方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的iter方法返回自身即可。

一个实现了iter方法和next方法的对象，就是迭代器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class MyList(object):
    def __init__(self):
        self.inner_list = list()

    def add(self,val):
        self.inner_list.append(val)

    def __iter__(self):
        return MyIterator(self)

class MyIterator(object):
    def __init__(self,my_list):
        self.current_idx = 0;
        self.inner_list = my_list.inner_list

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_idx < len(self.inner_list):
            tmp_val = self.inner_list[self.current_idx]
            self.current_idx +=1 
            return tmp_val
        else:
            raise StopIteration

if __name__ == "__main__":
    ml = MyList()
    ml.add(1)
    ml.add(2)
    ml.add(3)
    ml.add(4)
    ml.add(5)
    for i in ml: 
        print(i)

运行结果:

1
2
3
4
5
1
2
3
4
5

for … in …的本质

通过上面的代码例子，我们不妨来分析下for循环的本质。首先通过对象内部iter方法返回迭代器对象，然后不断地调用迭代器对象内部的next方法，返回内部元素。知道遇到StopIteration异常结束。

迭代器妙用

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

现在我们想要通过for…in…循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Fib(object):
    def __init__(self,n):
        self.n = n 
        self.a = 0 
        self.b = 1 
        self.current_idx = 0 

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_idx < self.n:
            tmp_val = self.a
            self.a,self.b = (self.b,self.a + self.b)
            self.current_idx +=1 
            return tmp_val
        else:
            raise StopIteration

if __name__ == "__main__":
    f = Fib(10)
    for i in f:
        print(i)

运行结果:

1
2
3
4
5
6
7
8
9
10
0
1
1
2
3
5
8
13
21
34

并不是只有for循环能接收可迭代对象

除了for循环能接收可迭代对象，list、tuple等也能接收。

1
2
3
4
li = list(Fib(10))
print(li)
tu = tuple(Fib(10))
print(tu)

运行结果:

1
2
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
(0, 1, 1, 2, 3, 5, 8, 13, 21, 34)