迭代器

迭代器是Python中最强大的功能之一 , 是访问集合元素的一种方式 .

迭代器是一个可以记住遍历位置的对象 .

迭代器对象从集合的第一个元素开始访问 , 直到所有元素被访问结束 . 迭代器只能往前不能后退 .

迭代器有两个基本的方法 : iter()和 next()

字符串 , 列表 或元组对象都可用于创建迭代器 .

1
2
3
4
list = [1,2,3,4]
it = iter(list)
print(next(it)) # 1
print(next(it)) # 2

迭代器对象可以使用常规for语句进行遍历 :

1
2
3
4
5
6
7
list = [1,2,3,4]
it = iter(list)
for x in it:
    print(x,end="")
    
# 执行以上程序的输出结果为
# 1 2 3 4

也可以使用next()函数 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import sys
list = [1,2,3,4]
it = iter(list)
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()
        
# 执行以上程序的输出结果如下:
'''
1
2
3
4
'''

创建一个迭代器

把一个类作为迭代器使用需要在类中实现__iter__()与__next__()两个特殊方法.

如果你已经了解了面向对象编程 , 就知道类都有一个构造函数 , Python中的构造函数为 __init__() , 它会在对象创建时执行.

__iter__()方法返回一个特殊的迭代器对象 , 这个迭代器对象实现了__next__()方法 并通过StopIteration异常标识迭代的完成.

__next__()方法会返回下一个迭代器对象.

创建一个返回数字的迭代器 , 初始值是1 , 逐步增 1 :

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
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    
    def __next__(self):
        x = self.a
        self.a += 1
        return x

myclass = MyNumbers()
it = iter(myclass)

print(type(it) , id(it))
print(type(myclass) , id(myclass))
print(isinstance(it,MyNumbers))

print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))

# 上述代码的执行结果是:
'''
<class '__main__.MyNumbers'> 1674286348560
<class '__main__.MyNumbers'> 1674286348560
True
1
2
3
4
5
'''

StopIteration

StopIteration 异常用于标识迭代的完成 , 防止出现无限循环的情况 , 在 __next__()方法中我们可以设置完成指定循环次数后触发 StopIteration异常来结束迭代 .

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
36
37
38
39
40
41
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    
    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration

myclass = MyNumbers()
it = iter(myclass)
for i in it:
    print(i)

# 执行结果
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'''

生成器

在Python中 , 使用了yield的函数被称为生成器 (generator) .

跟普通函数不同的是 , 生成器是一个返回迭代器的函数 , 只能用于迭代操作 , 更简单点理解生成器就是一个迭代器.

在调用生成器运行的过程中 , 每次遇到 yield 时 函数会暂停并保存当前所有的运行信息 , 返回 yield 的值 , 并在下一次执行 next()方法时从当前位置继续执行.

调用一个生成器函数 , 返回的是一个迭代器对象 .

以下实例使用 yield 实现斐波那契数列:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import sys

def fibonacci(n):
    a , b , counter = 0 ,1 ,0
    while True:
        if (counter > n):
            return
        yield a
        a , b = b ,a+b
        counter += 1
f = fibonacci(10)

while True:
    try:
        print(next(f),end = " ")
        pass
    except StopIteration:
        sys.exit()

# 执行以上程序 , 输出结果如下:
"""
0 1 1 2 3 5 8 13 21 34 55 
"""