Python 中的迭代器趣味实践

上节课我们学习了迭代器的实现原理，这节课我们来动手实践一下：

1. 遍历文本文件中的单词

假设存在文本文件 test.txt，内容如下：

The Zen of Python

Beautiful is better than ugly

Simple is better than complex

注意文件包含有空行，要求完成如下任务：

1. 统计文件有多少个单词
2. 统计文件中每个单词出现的频率

2. 直接遍历的方法

2.1 统计单词个数

假设没有学习迭代器，使用直接遍历的方法实现 “统计单词个数” 的功能需求，代码如下：

file = open('test.txt')
count = 0

while True:
    line = file.readline()
    if not line:
        break

    words = line.split() 
    for word in words:
        print(word)
        count = count + 1
print('count = %d' % count)

• 在第 1 行，打开文件 test.txt，变量 file 标识已经打开的文件
• 在第 2 行，变量 count 用于记录文件中单词的个数
• 程序逻辑由两个循环构成：外循环和内循环
  • 在第 4 行，外循环，遍历文件的每一行文本
    • 在第 5 行，读取文件的一行
    • 在第 6 行，如果 not line 为真，表示读取到文件的结束，退出程序
  • 在第 10 行，内循环，遍历每一行文本的单词
    • 在第 9 行，使用 split 方法将文本分割为多个单词，将结果保存在列表 words 中
    • 在第 10 行，使用 for 循环遍历列表 words
    • 在第 11 行，打印当前遍历的单词
    • 在第 12 行，统计单词个数
• 在第 13 行，打印单词的总个数

注意，程序能够对空行进行正确的处理：

• 在第 9 行，使用 split 方法将 line 分割为多个单词
• 如果 line 为空行，则 split 返回一个空列表 []
• 在第 11 行，使用 for 循环遍历一个空列表，不会执行 for 循环的循环体代码

程序运行输出结果如下：

The
Zen
of
Python
Beautiful
is
better
than
ugly
Simple
is
better
than
complex
count = 14

2.2 统计单词出现频率

假设没有学习迭代器，使用直接遍历的方法实现 “统计单词出现频率” 的功能需求，代码如下：

file = open('test.txt')
dict = {}

while True:
    line = file.readline()
    if not line:
        break

    words = line.split() 
    for word in words:
        if word in dict:
            dict[word] += 1
        else:
            dict[word] = 1

for word,count in dict.items():
    print('%s: %d' % (word, count))            

• 在第 1 行，打开文件 test.txt，变量 file 标识已经打开的文件
• 在第 2 行，字典 dict 用于记录文件中单词的出现频率
  • 字典 dict 的键为单词
  • 字典 dict 的值为该单词在文本中出现的次数
• 程序逻辑由两个循环构成：外循环和内循环
  • 在第 4 行，外循环，遍历文件的每一行文本
    • 在第 5 行，读取文件的一行
    • 在第 6 行，如果 not line 为真，表示读取到文件的结束，退出程序
  • 在第 10 行，内循环，遍历每一行文本的单词
    • 在第 9 行，使用 split 方法将文本分割为多个单词，将结果保存在列表 words 中
    • 在第 11 行，如果 word 已经存在于 dict 中
      • 则在第 12 行，该单词出现的次数加 1
    • 在第 13 行，如果 word 不存在于 dict 中
      • 则在第 14 行，该单词出现的次数初始化为 1
• 在第 16 行，打印 dict 的键和值

程序运行输出结果如下：

The: 1
Zen: 1
of: 1
Python: 1
Beautiful: 1
is: 2
better: 2
than: 2
ugly: 1
Simple: 1
complex: 1

结果表明：

• 单词 is better than 出现了 2 次
• 其它单词出现了 1 次

2.3 直接遍历的方法的问题

2.1 小节程序的框架与 2.2 小节程序的框架类似：

• 程序的主体结构由两重循环构成：外循环和内循环
• 外循环，遍历文件的每一行文本
• 内循环，遍历每一行文本的单词

它们的不同之处在于：

• 遍历每个单词时，2.1 小节的程序执行如下代码统计单词个数

count = count + 1

• 遍历每个单词时，2.2 小节的程序执行如下代码统计单词出现频率

if word in dict:
    dict[word] += 1
else:
    dict[word] = 1

这两个小节的程序的其它代码则完全一样，程序中存在明显的代码重复。

3. 使用迭代器的方法

3.1 可迭代对象与迭代器

本节实现类 IterateWord 用于简化遍历文本中的单词，**类 IterateWord 既是可迭代对象也是迭代器: **

• 类 IterateWord 是可迭代对象，提供了 __iter__ 方法，返回一个迭代器
• 类 IterateWord 是迭代器，提供了 __next__ 方法，返回下一个遍历的对象

类 IterateWord 的定义如下：

class IterateWord:
    def __init__(self, file):
        self.file = file
        self.words = []

• 在第 2 行，参数 file 指明了被遍历的文本文件
• 在第 3 行，将参数 file 保存到成员变量中
• 在第 4 行，IterateWord 将每一行文本分割为多个单词，保存在 self.words 中，该变量初始化为空列表

3.2 实现 __iter__ 方法

类 IterateWord 是一个可迭代对象，需要向外界提供 __iter__ 方法，该方法的实现如下：

    def __iter__(self):
        return self

类 IterateWord 既是可迭代对象也是迭代器，返回 self 表示 self 是一个迭代器。

3.3 实现 __next__ 方法

类 IterateWord 是一个迭代器，需要向外界提供 __next__ 方法，该方法的实现如下：

    def __next__(self):
        if len(self.words) == 0:
            self.get_non_blank_line()
        word = self.words.pop(0)
        return word

• 在第 1 行，定义 __next__ 方法
• IterateWord 读取一行文本后，将该文本分割为单词列表，保存在 words 中
  • 在第 2 行，如果列表 words 中的单词数量为 0
  • 在第 3 行，调用 get_non_blank_line 方法读取一个非空的行
• 在第 4 行，使用 words.pop(0) 从 words 中删除第 0 个单词，即该行文本的首个单词
• 在第 5 行，返回从 words 中删除的第 0 个单词

get_non_blank_line 方法读取一个非空的行，代码如下：

    def get_non_blank_line(self):
        while True:
            line = file.readline()
            if not line:
                raise StopIteration
            self.words = line.split() 
            if len(self.words) != 0:
                break

• 在第 2 行，使用循环依次读取文件的每行文本
• 在第 3 行，使用 readline 方法读取文件的一行文本
• 在第 4 行，not line 为真表示读取到文件结束
  • 在第 5 行，抛出异常 StopIteration，表示遍历结束
• 在第 6 行，将 line 分割为多个单词
  • 如果 line 是一个空行，则 len(words) == 0，需要跳过这种情况，读取下一行文本
  • 如果 line 不是一个空行，则 len(words) != 0，在第 7 行执行 break 退出循环，结束函数的执行，此时列表 self.words 中必定包含有若干个单词

4. 使用迭代器解决需求

4.1 统计单词个数

本节基于前面已经实现的迭代器，完成统计单词个数的任务，代码如下：

file = open('test.txt')
count = 0

for word in IterateWord(file):
    print(word)
    count = count + 1

• 在第 1 行，打开文件 test.txt
• 在第 2 行，变量 count 用于记录文件中单词的个数
• 在第 4 行，遍历文件中的每一个单词
  • 在第 5 行，打印当前遍历的单词
  • 在第 6 行，统计单词个数

程序运行输出结果如下：

The
Zen
of
Python
Beautiful
is
better
than
ugly
Simple
is
better
than
complex
count = 14

4.2 统计单词出现频率

file = open('test.txt')
dict = {}

for word in IterateWord(file):
    if word in dict:
        dict[word] += 1
    else:
        dict[word] = 1

for word,count in dict.items():
    print('%s: %d' % (word, count))          

• 在第 1 行，打开文件 test.txt，变量 file 标识已经打开的文件
• 在第 4 行，遍历每一行文本的单词
  • 在第 5 行，如果 word 已经存在于 dict 中
    • 则在第 5 行，该单词出现的次数加 1
  • 在第 7 行，如果 word 不存在于 dict 中
    • 则在第 8 行，该单词出现的次数初始化为 1
• 在第 10 行，打印 dict 的键和值

程序运行输出结果如下：

The: 1
Zen: 1
of: 1
Python: 1
Beautiful: 1
is: 2
better: 2
than: 2
ugly: 1
Simple: 1
complex: 1

结果表明：

• 单词 is better than 出现了 2 次
• 其它单词出现了 1 次

4.3 总结

4.3.1 简化了遍历的代码

基于迭代器的方法解决 “统计单词个数” 与 “统计单词出现频率” 这两个任务，遍历文本中的单词的代码非常简洁，如下所示：

for word in IterateWord(file):
    处理 word

IterateWord 屏蔽了文件由多行构成、可能存在空行、每行由多个单词构成等细节，遍历文件中的单词非常的方便。

4.3.2 迭代器的实现复杂

直接遍历文件单词的代码如下：

while True:
    line = file.readline()
    if not line:
        break

    words = line.split() 
    for word in words:
        处理 word

使用直接遍历文件单词的方式解决 “统计单词个数” 与 “统计单词出现频率” 这两个任务，存在有明显的代码重复。虽然代码重复，但是代码很直观、容易理解。

与之相比，IterateWord 的实现较为复杂、不够直观，Python 中提供了生成器的语法，可以用于简化迭代器的实现。请查找词条 “Python 中的生成器实现原理” 和 “Python 中的迭代器趣味实践”，阅读如何使用生成器简化实现迭代器。