Python3学习（五）:迭代器

92 阅读 0 评论 61 点赞

我是靠谱客的博主贤惠星星，这篇文章主要介绍Python3学习（五）:迭代器，现在分享给大家，希望可以做个参考。

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。

iter() 用来创建迭代器对象

复制代码

1
2
3
4
# iter()用来创建迭代器对象
list=[1,2,3,4]
it = iter(list)

next() 用来将迭代器对象向后移动

复制代码

1
2
next(it)

字符串(str)，列表(list)或元组(tuple)对象都可用于创建迭代器
即python中的三种序列，可以使用迭代器进行迭代

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

复制代码

1
2
3
4
5
str = "What can i do for you"
it = iter(str)
for i in it:
    print(i, end='')

也可以通过while和next 进行遍历

复制代码

1
2
3
4
5
6
7
8
9
10
11
import sys

list = [2, 4, "six", 8.0]
it = iter(list)

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

创建一个迭代器类

如果需要将一个类作为迭代器使用，必须实现 _iter_() 和 _next_() 这两个方法

_iter_() 方法返回一个自定义的迭代器对象，这个迭代器对象实现了 _next_() 方法并通过 StopIteration 异常标识迭代的完成。

_next_() 方法返回迭代器对象的下一个元素。

StopIteration 结束迭代

为防止无限循环，_next_() 方法中我们可以设置在完成指定循环次数后raise StopIteration

在 20 次迭代后停止执行：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyIterator():
    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
            
myiterator = MyIterator()
for it in myiterator:
    print(it, end=' ')

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）
生成器返回迭代器，只能用于迭代操作, 即生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。

使用 yield 实现斐波那契前10位:

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def fibonacci(n):
    a, b, count = 0, 1, 0
    while True:
        if count >= n:
            print("Iterate over!")
            return
        yield a
        a, b = b, a + b
        count += 1

f = fibonacci(10)

for i in f:
    print(i, end=" ")
# 或
# while True:
#     try:
#         print(next(f), end=' ')
#     except StopIteration:
#         sys.exit()

为什么使用yield？

有一个函数 f，f 返回一个 list，这个 list 是动态计算出来的（不管是数学上的计算还是逻辑上的读取格式化），并且这个 list 会很大（无论是固定很大还是随着输入参数的增大而增大），这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个 list 元素 , ~~而不是直接得到一个完整的 list~~,以此来节省内存，这个时候 yield 就很有用。

以斐波那契函数为例，我们一般希望从 n 返回一个 n 个数的 list：

复制代码

1
2
3
4
5
6
7
8
9
def fab(max): 
   n, a, b = 0, 0, 1 
   L = [] 
   while n < max: 
       L.append(b) 
       a, b = b, a + b 
       n = n + 1 
   return L

上面那个 fab 函数从参数 max 返回一个有 max 个元素的 list，当这个 max 很大的时候，会非常的占用内存。

一般我们使用的时候都是这个样子的，比如：

复制代码

1
2
3
4
5
6
7
f = iter(fab(1000))
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

这样我们实际上是先生成了一个 1000 个元素的 list:f，然后我们再去使用这个 f。

现在，我们换一个方法：

因为我们实际使用的是 list 的遍历，也就是 list 的迭代器。那么我们可以让这个函数 fab 每次只返回一个迭代器——一个计算结果，而不是一个完整的 list：

复制代码

1
2
3
4
5
6
7
8
def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1