迭代器#

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。

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

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

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

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

实例(Python 3.0+)#

1
>>> list = [1, 2, 3, 4]
2
>>> it = iter(list)  # 创建迭代器对象
3
>>> print(next(it))  # 输出迭代器的下一个元素
4
1
5
>>> print(next(it))
6
2
7
>>>

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

实例(Python 3.0+)#

1
list = [1, 2, 3, 4]
2
it = iter(list)
3
for x in it:
4
    print(x, end=" ")

执行以上程序，输出结果如下：

1
1 2 3 4

也可以使用 next() 函数：

实例(Python 3.0+)#

1
import sys
2
list = [1, 2, 3, 4]
3
it = iter(list)
4
while True:
5
    try:
6
        print(next(it))
7
    except StopIteration:
8
        sys.exit()

执行以上程序，输出结果如下：

1
1
2
2
3
3
4
4

实例(Python 3.0+)#

1
class MyNumbers:
2
    def __iter__(self):
3
        self.a = 1
4
        return self
5

6
    def __next__(self):
7
        x = self.a
8
        self.a += 1
9
        return x
10

11
myclass = MyNumbers()
12
myiter = iter(myclass)
13

14
print(next(myiter))
15
print(next(myiter))
16
print(next(myiter))
17
print(next(myiter))
18
print(next(myiter))

执行输出结果为：

1
1
2
2
3
3
4
4
5
5

实例(Python 3.0+)#

1
class MyNumbers:
2
    def __iter__(self):
3
        self.a = 1
4
        return self
5

6
    def __next__(self):
7
        if self.a <= 20:
8
            x = self.a
9
            self.a += 1
10
            return x
11
        else:
12
            raise StopIteration
13

14
myclass = MyNumbers()
15
myiter = iter(myclass)
16

17
for x in myiter:
18
    print(x)

执行输出结果为：

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

生成器#

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

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

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

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

下面是一个简单的示例，展示了生成器函数的使用：

实例#

1
def countdown(n):
2
    while n > 0:
3
        yield n
4
        n -= 1
5

6
generator = countdown(5)
7
print(next(generator))
8
print(next(generator))
9
print(next(generator))
10
for value in generator:
11
    print(value)

以上实例中， countdown 函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。

通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。在这个例子中，我们首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。

生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。此外，生成器还可以与其他迭代工具（如for循环）无缝配合使用，提供简洁和高效的迭代方式。

执行以上程序，输出结果如下：

1
5
2
4
3
3
4
2
5
1

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

实例(Python 3.0+)#

1
import sys
2

3
def fibonacci(n):
4
    a, b, counter = 0, 1, 0
5
    while True:
6
        if counter > n:
7
            return
8
        yield a
9
        a, b = b, a + b
10
        counter += 1
11

12
f = fibonacci(10)
13
while True:
14
    try:
15
        print(next(f), end=" ")
16
    except StopIteration:
17
        sys.exit()

执行以上程序，输出结果如下：

1
0 1 1 2 3 5 8 13 21 34 55

练习题#

• 1. 基本迭代器使用 创建文件 test_iter.py，完成以下操作：

  • 用 iter() 创建列表 [1, 2, 3, 4, 5] 的迭代器
  • 用 next() 逐个获取元素
  • 用 for 循环遍历剩余元素

  知识点： iter(列表) 创建迭代器、next(迭代器) 获取下一个

  参考答案：

  1
  lst = [1, 2, 3, 4, 5]
  2
  it = iter(lst)
  3
  
  4
  print(next(it))  # 1
  5
  print(next(it))  # 2
  6
  print(next(it))  # 3
  7
  
  8
  for x in it:
  9
      print(x, end=" ")  # 4 5
  10
  print()

• 2. 自定义迭代器类 创建文件 test_class.py，完成以下操作：

  • 创建一个迭代器类，生成 1-10 的数字

  知识点： iter() 返回迭代器对象、next() 返回下一个值

  说明：

  • __iter__() 方法：初始化迭代器，返回 self
  • __next__() 方法：每次调用返回下一个值，没有值时抛出 StopIteration 异常
  • 这是 Python 的迭代器协议，实现了这两个方法的类就是迭代器

  参考答案：

  1
  class MyNumbers:
  2
      def __iter__(self):
  3
          self.a = 1      # 初始化计数器
  4
          return self     # 返回迭代器对象
  5
  
  6
      def __next__(self):
  7
          if self.a <= 10:
  8
              x = self.a
  9
              self.a += 1
  10
              return x
  11
          else:
  12
              raise StopIteration  # 没有更多值时抛出异常
  13
  
  14
  myclass = MyNumbers()
  15
  for x in myclass:
  16
      print(x, end=" ")
  17
  print()

  显示更多显示更少

• 3. 生成器函数 创建文件 test_generator.py，完成以下操作：

  • 用 yield 创建一个生成器，生成 1-10 的平方数

  知识点： yield 暂停函数并返回值、生成器函数调用后返回生成器对象

  说明：

  • yield 关键字：暂停函数执行，返回一个值，下次调用时从暂停处继续
  • 生成器函数：包含 yield 的函数，调用后返回一个生成器对象
  • 可以用 next() 或 for 循环逐步获取值

  参考答案：

  1
  def squares(n):
  2
      for i in range(1, n + 1):
  3
          yield i ** 2  # 暂停并返回平方数
  4
  
  5
  gen = squares(10)  # 调用生成器函数，返回生成器对象
  6
  print(next(gen))  # 1
  7
  print(next(gen))  # 4
  8
  print(next(gen))  # 9
  9
  
  10
  for x in gen:
  11
      print(x, end=" ")  # 16 25 36 49 64 81 100
  12
  print()

• 4. 斐波那契生成器 创建文件 test_fibonacci.py，完成以下操作：

  • 用 yield 实现斐波那契数列生成器

  知识点： yield a 返回当前值、a, b = b, a + b 同时赋值

  说明：

  • 斐波那契数列：0, 1, 1, 2, 3, 5, 8, 13…（每个数是前两个数之和）
  • a, b = b, a + b 是同时赋值：先计算右边，再同时赋给左边

  参考答案：

  1
  def fibonacci():
  2
      a, b = 0, 1
  3
      while True:
  4
          yield a      # 返回当前斐波那契数
  5
          a, b = b, a + b  # 计算下一个数
  6
  
  7
  fib = fibonacci()
  8
  for _ in range(20):
  9
      print(next(fib), end=" ")
  10
  print()