原文： http://zetcode.com/lang/python/itergener/

在 Python 教程的这一部分中，我们将使用插入器和生成器。 迭代器是一个对象，它使程序员可以遍历集合的所有元素，而不管其具体实现如何。

在 Python 中，迭代器是实现迭代器协议的对象。 迭代器协议包含两种方法。 __iter__()方法必须返回迭代器对象，而next()方法必须返回序列中的下一个元素。

迭代器具有以下优点：

  • 干净的代码
  • 迭代器可以处理无限序列
  • 迭代器节省资源

Python 有几个内置对象，它们实现了迭代器协议。 例如列表，元组，字符串，字典或文件。

iterator.py

  1. #!/usr/bin/env python
  3. # iterator.py
  5. str = "formidable"
  7. for e in str:
  8.    print(e, end=" ")
  10. print()
  12. it = iter(str)
  14. print(it.next())
  15. print(it.next())
  16. print(it.next())
  18. print(list(it))

在代码示例中，我们显示了字符串上的内置迭代器。 在 Python 中，字符串是不可变的字符序列。 iter()函数返回对象的迭代器。 我们还可以在迭代器上使用list()或tuple()函数。

  1. $ ./iterator.py 
  2. f o r m i d a b l e
  3. f
  4. o
  5. r
  6. ['m', 'i', 'd', 'a', 'b', 'l', 'e']

Python 阅读一行

通过节省系统资源，我们的意思是在使用迭代器时，我们可以获取序列中的下一个元素，而无需将整个数据集保留在内存中。

read_data.py

  1. #!/usr/bin/env python
  3. # read_data.py
  5. with open('data.txt', 'r') as f:
  7.     while True:
  9.         line = f.readline()
  11.         if not line: 
  12.             break
  14.         else: 
  15.             print(line.rstrip())

此代码打印data.txt文件的内容。 除了使用while循环外，我们还可以应用迭代器来简化我们的任务。

read_data_iterator.py

  1. #!/usr/bin/env python
  3. # read_data_iterator.py
  5. with open('data.txt', 'r') as f:
  7.     for line in f:
  8.         print(line.rstrip())

open()函数返回一个文件对象，它是一个迭代器。 我们可以在for循环中使用它。 通过使用迭代器，代码更清晰。

Python 迭代器协议

在下面的示例中，我们创建一个实现迭代器协议的自定义对象。

iterator_protocol.py

  1. #!/usr/bin/env python
  3. # iterator_protocol.py
  5. class Seq:
  7.    def __init__(self):
  9.       self.x = 0
  11.    def __next__(self):
  13.       self.x += 1
  14.       return self.x**self.x
  16.    def __iter__(self):
  18.       return self
  20. s = Seq()
  21. n = 0
  23. for e in s:
  25.    print(e)
  26.    n += 1
  28.    if n > 10:
  29.       break

在代码示例中，我们创建了一个数字序列 1，4，27，256，…。 这表明使用迭代器，我们可以处理无限序列。

  1. def __iter__(self):
  3.     return self

for语句在容器对象上调用__iter__()函数。 该函数返回一个定义方法__next__()的迭代器对象，该方法一次访问一个容器中的元素。

  1.  def next(self):
  2.     self.x += 1
  3.     return self.x**self.x

next()方法返回序列的下一个元素。

  1. if n > 10:
  2.     break

因为我们正在处理无限序列，所以我们必须中断for循环。

  1. $ ./iterator.py 
  2. 1
  3. 4
  4. 27
  5. 256
  6. 3125
  7. 46656
  8. 823543
  9. 16777216
  10. 387420489
  11. 10000000000
  12. 285311670611

StopIteration

循环可以以其他方式中断。 在类定义中，我们必须引发一个StopIteration异常。 在以下示例中，我们重做上一个示例。

stopiter.py

  1. #!/usr/bin/env python
  3. # stopiter.py
  5. class Seq14:
  7.    def __init__(self):
  8.       self.x = 0
  10.    def __next__(self):
  12.       self.x += 1
  14.       if self.x > 14:
  15.          raise StopIteration
  17.       return self.x ** self.x
  19.    def __iter__(self):
  20.       return self
  22. s = Seq14()
  24. for e in s:
  25.    print(e)

该代码示例将打印序列的前 14 个数字。

  1. if self.x > 14:
  2.     raise StopIteration

StopIteration异常将停止for循环。

  1. $ ./stop_iter.py 
  2. 1
  3. 4
  4. 27
  5. 256
  6. 3125
  7. 46656
  8. 823543
  9. 16777216
  10. 387420489
  11. 10000000000
  12. 285311670611
  13. 8916100448256
  14. 302875106592253
  15. 11112006825558016

这是示例的输出。

Python 生成器

生成器是一个特殊的例程，可用于控制循环的迭代行为。 生成器类似于返回数组的函数。 生成器具有参数，可以调用它并生成数字序列。 但是，与返回整个数组的函数不同，生成器一次生成一个值。 这需要较少的内存。

Python 中的生成器：

  • 用def关键字定义
  • 使用yield关键字
  • 可以使用几个yield关键字
  • 返回一个迭代器

让我们看一个生成器示例。

simple_generator.py

  1. #!/usr/bin/env python
  3. # simple_generator.py
  5. def gen():
  7.    x, y = 1, 2
  8.    yield x, y
  10.    x += 1
  11.    yield x, y
  13. g = gen()
  15. print(next(g))
  16. print(next(g))
  18. try:
  19.    print(next(g))
  21. except StopIteration:
  22.    print("Iteration finished")

该程序将创建一个非常简单的生成器。

  1. def gen():
  3.    x, y = 1, 2
  4.    yield x, y
  6.    x += 1
  7.    yield x, y

就像正常函数一样，生成器使用def关键字定义。 我们在生成器主体内使用两个yield关键字。 yield关键字退出生成器并返回一个值。 下次调用迭代器的next()函数时，我们在yield关键字之后的行继续。 请注意，局部变量会在整个迭代过程中保留。 当没有余量可产生时，将引发StopIteration异常。

  1. $ ./generator.py 
  2. (1, 2)
  3. (2, 2)
  4. Iteration finished

在以下示例中，我们计算斐波纳契数。 序列的第一个数字为 0，第二个数字为 1，并且每个后续数字等于序列本身前两个数字的和。

fibonacci_gen.py

  1. #!/usr/bin/env python
  3. # fibonacci_gen.py
  5. import time
  7. def fib():
  9.    a, b = 0, 1
  11.    while True:
  12.       yield b
  14.       a, b = b, a + b
  16. g = fib()
  18. try:
  19.    for e in g:
  20.       print(e)
  22.       time.sleep(1)
  24. except KeyboardInterrupt:
  25.    print("Calculation stopped")

该脚本将 Fibonacci 数字连续打印到控制台。 用 Ctrl + C 组合键终止。

Python 生成器表达式

生成器表达式类似于列表推导。 区别在于生成器表达式返回的是生成器，而不是列表。

generator_expression.py

  1. #!/usr/bin/env python
  3. # generator_expression.py
  5. n = (e for e in range(50000000) if not e % 3)
  7. i = 0
  9. for e in n:
  10.     print(e)
  12.     i += 1
  14.     if i > 100:
  15.         raise StopIteration

该示例计算的值可以除以 3，而没有余数。

  1. n = (e for e in range(50000000) if not e % 3)

将使用圆括号创建生成器表达式。 在这种情况下，创建列表推导式将非常低效，因为该示例将不必要地占用大量内存。 为此，我们创建了一个生成器表达式，该表达式根据需要延迟生成值。

  1. i = 0
  3. for e in n:
  4.     print(e)
  6.     i += 1
  8.     if i > 100:
  9.         raise StopIteration

在for循环中，我们使用生成器生成 100 个值。 我们这样做时并没有大量使用内存。

在下一个示例中，我们使用生成器表达式在 Python 中创建类似grep的工具。

roman_empire.txt

  1. The Roman Empire (Latin: Imperium Rōmānum; Classical Latin: [ɪmˈpɛ.ri.ũː roːˈmaː.nũː] 
  2. Koine and Medieval Greek: Βασιλεία τῶν Ῥωμαίων, tr. Basileia tōn Rhōmaiōn) was the 
  3. post-Roman Republic period of the ancient Roman civilization, characterized by government 
  4. headed by emperors and large territorial holdings around the Mediterranean Sea in Europe, 
  5. Africa and Asia. The city of Rome was the largest city in the world c. 100 BC – c. AD 400, 
  6. with Constantinople (New Rome) becoming the largest around AD 500,[5][6] and the Empire's 
  7. populace grew to an estimated 50 to 90 million inhabitants (roughly 20% of the world's 
  8. population at the time).[n 7][7] The 500-year-old republic which preceded it was severely 
  9. destabilized in a series of civil wars and political conflict, during which Julius Caesar 
  10. was appointed as perpetual dictator and then assassinated in 44 BC. Civil wars and executions 
  11. continued, culminating in the victory of Octavian, Caesar's adopted son, over Mark Antony and 
  12. Cleopatra at the Battle of Actium in 31 BC and the annexation of Egypt. Octavian's power was 
  13. then unassailable and in 27 BC the Roman Senate formally granted him overarching power and 
  14. the new title Augustus, effectively marking the end of the Roman Republic.

我们使用此文本文件。

generator_expression.py

  1. #!/usr/bin/env python
  3. # gen_grep.py
  5. import sys
  7. def grep(pattern, lines):
  8.     return ((line, lines.index(line)+1) for line in lines if pattern in line)
  10. file_name = sys.argv[2]
  11. pattern = sys.argv[1]
  13. with open(file_name, 'r') as f:
  14.     lines = f.readlines()
  16.     for line, n in grep(pattern, lines):
  17.         print(n, line.rstrip())

该示例从文件中读取数据，并打印包含指定模式及其行号的行。

  1. def grep(pattern, lines):
  2.     return ((line, lines.index(line)+1) for line in lines if pattern in line)

类似于grep的工具使用此生成器表达式。 该表达式遍历行列表并选择包含模式的行。 它计算列表中该行的索引，即它在文件中的行号。

  1. with open(file_name, 'r') as f:
  2.     lines = f.readlines()
  4.     for line, n in grep(pattern, lines):
  5.         print(n, line.rstrip())

我们打开文件进行读取，然后对数据调用grep()函数。 该函数返回一个生成器，该生成器通过for循环遍历。

  1. $ ./gen_grep.py Roman roman_empire.txt 
  2. 1 The Roman Empire (Latin: Imperium Rōmānum; Classical Latin: [ɪmˈpɛ.ri.ũː roːˈmaː.nũː]
  3. 3 post-Roman Republic period of the ancient Roman civilization, characterized by government
  4. 13 then unassailable and in 27 BC the Roman Senate formally granted him overarching power and
  5. 14 the new title Augustus, effectively marking the end of the Roman Republic.

文件中有四行包含Roman字。

在本章中，我们介绍了 Python 中的迭代器和生成器。