登录
目录
当前位置： 首页 > 文档资料 > Python 进阶应用教程 >

08 Python 中的迭代器趣味实践

优质
小牛编辑
148浏览
2023-12-01

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

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 中的迭代器趣味实践”，阅读如何使用生成器简化实现迭代器。

免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn