Python进阶————迭代器与生成器

---

---

前言

• 我们之前学习遍历的时候，系统会一下子给我们显示所有的数据，我们希望当我们需要数据的时候再给我们数据，那么，我们就需要迭代器与生成器的帮助。
• 迭代器和生成器在Python中都是用来处理数据序列的重要工具，它们之间的主要区别在于实现方式和使用场景的不同。

---

一、迭代器

• 迭代器是一个实现了迭代协议的对象。迭代协议意味着迭代器必须拥有__iter__和__next__方法。当一个对象实现了这两个方法，我们就称它为迭代器。
• __iter__方法返回迭代器自身，而__next__方法返回序列中的下一个值。
• 如果序列已经到了末尾，则抛出StopIteration异常。
• 迭代器的一个重要特点是它们是“状态感知”的，也就是说它们记得上次停留的位置，允许用户继续从停止的地方开始。

自定义代码实现迭代器（示例）：

# 导包, sys: 系统模块
import sys

# 定义1个类, 模拟: 迭代器.
class MyIterator:
    # 1. 初始化属性
    def __init__(self, limit):
        self.limit = limit      # 表示迭代次数(即: 你要的值的范围)
        self.current = 0        # 表示当前的元素.

    # 2. 返回迭代器对象本身.
    def __iter__(self):
        return self     # self = 迭代器对象.

    # 3. 自定义代码, 表示: 迭代器的规则, 即: 获取下一个元素.
    def __next__(self):
        # 3.1 判断, 数据不合法, 就停止迭代.
        if self.current >= self.limit:
            # raise: 抛出异常, 并终止程序运行的.
            raise StopIteration     # 抛出异常, StopIteration: 迭代结束.
            # raise ValueError('迭代器中没有数据了, 你还迭代, 我就报错了.')
            # raise ValueError('停止迭代!')

        # 3.2 获取下个元素, 并返回即可.
        self.current += 1
        return self.current

if __name__ == '__main__':
    # 案例1: 名词解释, 迭代: 逐个的获取容器中每个元素的过程称之为: 迭代, 也叫遍历.
    list1 = [1, 2, 3]
    # 迭代
    for i in list1:
        print(i)
    print('-' * 30)


	# 案例2: 演示自定义的迭代器
    # 1. 创建迭代器对象.
    my_iter = MyIterator(5)     # 底层调用 iter魔法方法, 返回本身(迭代器对象本身)
    print(type(my_iter))        # 

    # 2. 从迭代器中获取元素.
    print(next(my_iter))        # 底层调用 next魔法方法, 返回下一个元素
    print('-' * 30)
    # 还可以遍历.
    for i in my_iter:           # 底层调用 next魔法方法, 返回下一个元素
        print(i)
    print('-' * 30)
    # 遍历完后, 迭代器已经没有元素了, 继续迭代会报错.
    print(next(my_iter))        # 底层调用 next魔法方法, 返回下一个元素

二、生成器

• 生成器是Python中的一种特殊类型的迭代器，它通常由包含yield语句的函数来定义。与常规函数不同，生成器不会一次性返回所有结果，而是返回一个迭代器对象。
• 当调用生成器函数时，它返回一个未执行的生成器对象，当这个对象的__next__方法被调用时，函数开始执行直到遇到yield语句，此时函数的状态会被保存，并返回一个值。当再次调用__next__时，函数从上次停止的地方继续执行，直到再次遇到yield或抛出StopIteration异常

2.1 创建生成器的两种方式

2.1.1 生成器推导式

案例1：回顾之前的列表推导式，集合推导式

# 需求: 生成 1 ~ 5 的数据.
my_list = [i for i in range(1, 6)]
print(my_list, type(my_list))   # [1, 2, 3, 4, 5] 

my_set = {i for i in range(1, 6)}
print(my_set, type(my_set))     # {1, 2, 3, 4, 5} 

案例2： 演示 生成器写法1，推导式写法

# 尝试写一下, "元组"推导式, 发现打印的结果不是元组, 而是对象, 因为这种写法叫: 生成器.
my_tuple = (i for i in range(1, 6))

print(my_tuple)             #  at 0x0000024C90F056D0>    生成器对象
print(type(my_tuple))       #        生成器类型
print('-' * 30)

# 案例3: 如何从生成器对象中获取数据呢?
# 1. 定义生成器, 获取 1 ~ 5的数字.
my_generator = (i for i in range(1, 6))

# 2. 从生成器中获取数据.
# 格式1: for循环遍历 获取全部
for i in my_generator:
    print(i)

# 格式 2: next()函数, 逐个获取.
print(next(my_generator))       # 1
print(next(my_generator))       # 2

2.1.2 yield关键字

代码 演示 yield关键字方式，获取生成器

# 需求: 自定义 get_generator()函数, 获取 包括: 1 ~ 5之间的整数 生成器.
# 1. 定义函数.
def get_generator():
    """
    用于演示 yield关键字的用法
    :return: 生成器对象.
    """
    # 思路1: 自定义列表, 添加指定元素, 并返回.
    # my_list = []
    # for i in range(1, 6):
    #     my_list.append(i)
    # return my_list

    # 思路2: yield写法, 即: 如下的代码, 效果同上.
    for i in range(1, 6):
        yield i     # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.


# 在main中测试.
if __name__ == '__main__':
    # 2. 调用函数, 获取生成器对象.
    my_generator = get_generator()

    # 3. 从生成器中获取每个元素.
    print(next(my_generator))   # 1
    print(next(my_generator))   # 2

    print('-' * 30)

    # 4. 遍历, 获取每个元素.
    for i in my_generator:
        print(i)

2.2 使用生成器 生成批次数据

代码用生成器生成批次数据：

# 需求: 读取项目下的  jaychou_lyrics.txt文件(其中有5000多条 歌词数据), 按照8个 / 批次, 获取生成器, 并从中获取数据.
import math

# 需求1: 铺垫知识,  math.ceil(数字):  获取指定数字的天花板数(向上取整), 即: 比这个数字大的所有整数中, 最小的哪个整数.
# print(math.ceil(5.1))       # 6
# print(math.ceil(5.6))       # 6
# print(math.ceil(5.0))       # 5


# 需求2: 获取生成器对象, 从文件中读数据数据, n条 / 批次
# 1. 定义函数 dataset_loader(batch_size), 表示: 数据生成器, 按照 batch_size条 分批.
def dataset_loader(batch_size):     # 假设: batch_size = 8
    """
    该函数用于获取生成器对象, 每条数据都是一批次的数据. 即: 生成器(8条, 8条, 8条...)
    :param batch_size: 每批次有多少条数据
    :return: 返回生成器对象.
    """
    # 1.1 读取文件, 获取到每条(每行)数据.
    with open("./jaychou_lyrics.txt", 'r', encoding='utf-8') as f:
        # 一次读取所有行, 每行封装成字符串, 整体放到列表中.
        data_lines = f.readlines()      # 结果: [第一行, 第二行, 第三行...]

    # 1.2 根据上述的数据, 计算出: 数据的总条数(总行数), 假设: 100行(条)
    line_count = len(data_lines)

    # 1.3 基于上述的总条数 和 batch_size(每批次的条数), 获取: 批次总数(即: 总共多少批)
    batch_count = math.ceil(line_count / batch_size)        # 例如: math.ceil(100 / 8) = 13

    # 1.4 具体的获取每批次数据的动作, 用 yield包裹, 放到生成器中, 并最终返回生成器(对象)即可.
    for i in range(batch_count):        # batch_count的值: 13,  i的值: 0, 1, 2, 3, 4, 5, .... 12
        # 1.5 yield会记录每批次数据, 封装到生成器中, 并返回(生成器对象)
        """
            推理过程:
                i = 0, 代表第1批次数据, 想要 第 1 条   ~~~~  第 8 条数据,    即:  data_lines[0:8]      
                i = 1, 代表第2批次数据, 想要 第 9 条   ~~~~  第 16 条数据,   即:  data_lines[8:16]      
                i = 2, 代表第3批次数据, 想要 第 17 条   ~~~~  第 24 条数据,  即:  data_lines[16:24]
                ......      
        """
        yield data_lines[i * batch_size: i * batch_size + batch_size]

# 在main中, 测试调用
if __name__ == '__main__':
    # 2. 获取生成器对象.
    my_generator = dataset_loader(13)

    # 3. 从生成器中获取第 1 批数据.
    print(next(my_generator))
    # 从第一批次中, 获取具体的每一条数据.
    for line in next(my_generator):
        print(line, end='')
    
    print('-' * 31)
    
    # 从第二批次中, 获取具体的每一条数据.
    for line in next(my_generator):
        print(line, end='')
    print('-' * 31)


    # 4. 查看具体的每一批数据.
    for batch_data in my_generator:
        print(batch_data)

三、区别与联系

3.1 区别

• 内存效率：生成器比迭代器更加内存友好。迭代器可能会一次性加载所有数据到内存中，而生成器则是按需生成数据。
• 使用场景：迭代器通常用于遍历已存在的集合，而生成器则用于生成可能无限大的序列，或者在需要时才计算值的情况。
• 生命周期：生成器只能被遍历一次，因为它们在每次迭代之后会保留状态，一旦到达序列的末尾就会抛出StopIteration异常并关闭自身。而迭代器理论上可以被多次遍历，尽管实际上许多迭代器设计为只遍历一次。
• 创建方式：迭代器可以通过实现特定接口来创建，而生成器通常是通过带有yield语句的函数来创建。

3.2 联系

• 都是迭代协议的实现：无论是迭代器还是生成器，它们都遵循迭代协议，即实现了__iter__和__next__方法。
• 都可以被迭代：由于生成器本身就是迭代器的一种，所以它们都可以使用for循环或其他迭代机制来访问。
• 都支持懒加载：两者都支持懒加载模式，即在需要时才生成数据，这对于处理大数据集尤其有用。

---

总结

• 总结来说，迭代器和生成器在Python中都是用来处理数据序列的重要工具，它们之间的主要区别在于实现方式和使用场景的不同。