如何分离迭代器类的构造函数与迭代器？避免重复调用高开销构造

这问题我碰到过好几次！核心问题就是你把「高开销的数据准备」和「迭代器的状态管理」绑在同一个类里了，每次循环新建实例就会重复执行构造函数的耗时操作。给你几个实用的解决方案，从类的拆分到轻量的生成器都有：

方案1：拆分数据源与迭代器类（最清晰的类设计） #

把一次性计算的逻辑单独放到一个DataSource类里，迭代器类只负责迭代状态（比如索引），并依赖已准备好的数据源。这样数据源只初始化一次，迭代器可以多次创建，完全不会重复执行高开销操作。

举个Python代码例子：

# 负责一次性计算并存储数据的数据源类
class DataSource:
    def __init__(self):
        # 这里只执行一次高开销操作：比如读取大文件、复杂运算
        print("高开销构造函数仅调用一次！")
        self.processed_data = [1, 2, 3, 4, 5]  # 模拟高开销计算结果

# 专门的迭代器类，只处理迭代逻辑
class DataIterator:
    def __init__(self, data_source):
        self.data_source = data_source
        self.current_index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_index >= len(self.data_source.processed_data):
            raise StopIteration
        value = self.data_source.processed_data[self.current_index]
        self.current_index += 1
        return value

# 使用方式：先初始化一次数据源
my_data = DataSource()

# 多次循环，每次创建新的迭代器，但数据源不会重新计算
for item in DataIterator(my_data):
    print(item)

for item in DataIterator(my_data):
    print(item)

方案2：让数据源类直接支持迭代（更易用） #

如果想让用法更贴近原来的习惯，可以让DataSource类自己实现__iter__方法，每次调用这个方法时返回一个新的迭代器实例。这样用户不用显式创建迭代器，直接用数据源对象循环即可。

代码示例：

class DataSource:
    def __init__(self):
        print("高开销构造函数仅调用一次！")
        self.processed_data = [1, 2, 3, 4, 5]  # 高开销计算结果

    def __iter__(self):
        # 每次迭代都返回一个全新的迭代器，状态独立
        return self._DataIterator(self)

    # 把迭代器定义为内部类，更封装
    class _DataIterator:
        def __init__(self, data_source):
            self.data_source = data_source
            self.current_index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self.current_index >= len(self.data_source.processed_data):
                raise StopIteration
            value = self.data_source.processed_data[self.current_index]
            self.current_index += 1
            return value

# 使用起来非常自然，和原来的写法类似，但只初始化一次数据源
my_data = DataSource()

for item in my_data:
    print(item)

for item in my_data:
    print(item)

方案3：用生成器函数（轻量无类方案） #

如果你的迭代逻辑不复杂，不需要完整的类结构，用生成器函数结合闭包是最简洁的方式。先一次性计算好数据，再返回一个生成器工厂，每次调用工厂都会生成新的迭代器。

代码示例：

def create_data_generator():
    # 这里只执行一次高开销计算
    print("高开销计算仅执行一次！")
    processed_data = [1, 2, 3, 4, 5]

    # 生成器函数，每次调用都会返回全新的迭代器
    def data_generator():
        for item in processed_data:
            yield item

    return data_generator

# 先初始化一次，拿到生成器工厂
data_gen_factory = create_data_generator()

# 多次循环，每次调用工厂都得到新的迭代器，数据不会重新计算
for item in data_gen_factory():
    print(item)

for item in data_gen_factory():
    print(item)

核心思路总结 #

不管用哪种方案，本质都是把「一次性高开销的数据准备」和「可重复的迭代状态管理」彻底解耦：

• 数据准备只执行一次，结果被保存下来
• 每次循环都重新初始化迭代的状态（比如索引重置），但复用已准备好的数据，不会重复消耗资源

内容的提问来源于stack exchange，提问作者Dzung Nguyen