在Python中，如何通过抽象基类实现生成器、迭代器、可迭代对象？

在Python中，抽象基类（Abstract Base Class, ABC）是定义接口规范的“模板”，它通过@abstractmethod强制子类实现特定方法，确保所有子类都符合统一的接口标准。对于可迭代对象、迭代器、生成器这三者，Python的collections.abc模块提供了对应的抽象基类（Iterable、Iterator、Generator），我们可以通过继承这些基类并实现必填方法，来规范它们的实现。

一、核心抽象基类与继承关系

在开始实现前，先明确三者对应的抽象基类及其继承关系（从泛到专）：

collections.abc.Iterable  # 可迭代对象的抽象基类
        ↑ 继承
collections.abc.Iterator  # 迭代器的抽象基类（同时是可迭代对象）
        ↑ 继承
collections.abc.Generator # 生成器的抽象基类（同时是迭代器和可迭代对象）

• Iterable：要求实现__iter__()方法（返回一个迭代器）；
• Iterator：继承自Iterable，额外要求实现__next__()方法（返回下一个元素，无元素时抛StopIteration），且__iter__()需返回自身；
• Generator：继承自Iterator，额外要求实现send()、throw()、close()方法（支持生成器的交互与关闭）。

二、通过抽象基类实现可迭代对象（Iterable）

可迭代对象的核心是“能被for循环遍历”，其抽象基类Iterable强制要求实现__iter__()方法，该方法必须返回一个迭代器（Iterator实例）。

实现步骤：

1. 继承collections.abc.Iterable；
2. 用@abstractmethod装饰__iter__()方法，并实现它（返回一个迭代器）。

示例：自定义可迭代对象（存储学生姓名的容器）

from collections.abc import Iterable, Iterator
from abc import abstractmethod

class StudentIterable(Iterable):
    """自定义可迭代对象：存储学生姓名，支持遍历"""
    
    def __init__(self, names):
        self.names = names  # 存储学生姓名（原始数据）
    
    @abstractmethod  # 强制子类实现，但此处我们直接实现
    def __iter__(self):
        """返回一个迭代器（负责实际遍历逻辑）"""
        return StudentIterator(self.names)  # 返回自定义迭代器


# 配套的迭代器（负责遍历逻辑，后面会详细实现迭代器）
class StudentIterator(Iterator):
    def __init__(self, names):
        self.names = names
        self.index = 0  # 遍历索引
    
    def __next__(self):
        if self.index < len(self.names):
            result = self.names[self.index]
            self.index += 1
            return result
        raise StopIteration  # 遍历结束
    
    def __iter__(self):
        return self  # 迭代器的__iter__返回自身


# 使用可迭代对象
students = StudentIterable(["Alice", "Bob", "Charlie"])
# 可被for循环遍历（因为实现了__iter__，返回迭代器）
for name in students:
    print(name)
# 输出：
# Alice
# Bob
# Charlie

# 验证是否为可迭代对象
print(isinstance(students, Iterable))  # 输出：True

三、通过抽象基类实现迭代器（Iterator）

迭代器的核心是“实现遍历逻辑”，其抽象基类Iterator继承自Iterable，因此需要同时实现：

• __iter__()：返回自身（确保迭代器也是可迭代对象，能被for循环遍历）；
• __next__()：返回下一个元素，无元素时抛出StopIteration。

实现步骤：

1. 继承collections.abc.Iterator；
2. 实现__next__()（核心遍历逻辑）和__iter__()（返回自身）。

示例：自定义迭代器（遍历1到n的整数）

from collections.abc import Iterator
from abc import abstractmethod

class RangeIterator(Iterator):
    """自定义迭代器：遍历1到n的整数"""
    
    def __init__(self, max_num):
        self.max_num = max_num  # 最大整数
        self.current = 1  # 当前遍历到的整数
    
    def __next__(self):
        """返回下一个元素，无元素时抛异常"""
        if self.current <= self.max_num:
            result = self.current
            self.current += 1
            return result
        raise StopIteration  # 遍历结束
    
    def __iter__(self):
        """迭代器必须返回自身（因为它也是可迭代对象）"""
        return self


# 使用迭代器
iterator = RangeIterator(3)
# 方式1：用next()逐个获取
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
# print(next(iterator))  # 报错：StopIteration

# 方式2：用for循环遍历（因为实现了__iter__）
iterator2 = RangeIterator(3)
for num in iterator2:
    print(num)  # 1 2 3

# 验证是否为迭代器
print(isinstance(iterator, Iterator))  # 输出：True

四、通过抽象基类实现生成器（Generator）

生成器是“增强版迭代器”，支持“暂停-恢复”和“双向数据传递”。其抽象基类Generator继承自Iterator，因此除了__iter__()和__next__()，还必须实现：

• send(value)：向生成器发送数据（该数据会成为上一个yield的返回值），返回下一个yield的值；
• throw(type, value=None, traceback=None)：向生成器抛出异常，用于中断生成器；
• close()：关闭生成器（后续调用会直接抛StopIteration）。

实现步骤：

1. 继承collections.abc.Generator；
2. 实现__next__()（生成下一个元素）、send()（传递数据）、throw()（抛异常）、close()（关闭生成器）。

示例：自定义生成器（支持发送数据的计数器）

from collections.abc import Generator
from abc import abstractmethod

class CounterGenerator(Generator):
    """自定义生成器：计数，支持通过send()调整步长"""
    
    def __init__(self, start=1):
        self.current = start  # 当前计数
        self.step = 1  # 步长（默认1）
        self.closed = False  # 是否关闭
    
    def __next__(self):
        """生成下一个计数（等价于send(None)）"""
        if self.closed:
            raise StopIteration
        result = self.current
        self.current += self.step
        return result
    
    def send(self, value):
        """向生成器发送数据（调整步长），返回下一个计数"""
        if self.closed:
            raise StopIteration
        if value is not None:
            self.step = value  # 用发送的值更新步长
        return self.__next__()  # 调用__next__()返回下一个值
    
    def throw(self, exc_type, value=None, traceback=None):
        """向生成器抛出异常，中断执行"""
        self.closed = True
        if value is None:
            value = exc_type()
        raise value  # 抛出异常
    
    def close(self):
        """关闭生成器"""
        self.closed = True


# 使用生成器
gen = CounterGenerator(start=1)
print(next(gen))  # 1（默认步长1，current=1+1=2）
print(gen.send(2))  # 发送步长2 → 返回current=2 → 之后current=2+2=4
print(next(gen))  # 返回4 → current=4+2=6
print(gen.send(3))  # 发送步长3 → 返回6 → current=6+3=9

# 关闭生成器
gen.close()
# print(next(gen))  # 报错：StopIteration（已关闭）

# 验证是否为生成器
print(isinstance(gen, Generator))  # 输出：True

五、为什么要用抽象基类实现？—— 接口规范与类型安全

不用抽象基类也能实现迭代器/生成器（比如不继承Iterator，但手动实现__iter__和__next__），但通过ABC实现有两个核心优势：

1. 强制接口规范：
   抽象基类通过@abstractmethod强制子类实现必要方法（如Iterator必须有__next__），避免因遗漏方法导致的逻辑错误。例如，若继承Iterator但不实现__next__，实例化时会直接报错：

   class BadIterator(Iterator):
       pass  # 未实现__next__和__iter__
   
   # 实例化时报错：Can't instantiate abstract class BadIterator with abstract method __next__
   bad = BadIterator()
   

2. 支持类型检查：
   用isinstance或issubclass检查时，基于ABC实现的类能正确返回结果。例如，非ABC实现的“伪迭代器”可能无法通过isinstance(obj, Iterator)检查，而基于ABC实现的类可以：

   # 非ABC实现的伪迭代器（虽然能遍历，但isinstance检查不通过）
   class FakeIterator:
       def __next__(self): return 1
       def __iter__(self): return self
   
   print(isinstance(FakeIterator(), Iterator))  # 输出：False（不被认可为迭代器）
   
   # ABC实现的迭代器（检查通过）
   print(isinstance(RangeIterator(3), Iterator))  # 输出：True
   

六、总结：三类对象的ABC实现要点

对象类型	抽象基类	必须实现的方法	核心作用
可迭代对象	Iterable	__iter__()（返回一个迭代器）	提供“可被遍历”的入口
迭代器	Iterator	__next__()（返回下一个元素）、__iter__()（返回自身）	实现具体的遍历逻辑
生成器	Generator	__next__()、send()、throw()、close()	支持“暂停-恢复”和双向数据交互

通过抽象基类实现的核心是“遵循接口规范”——ABC定义了“必须做什么”，而子类负责“具体怎么做”。这种方式能让代码更健壮、可维护性更强，尤其在大型项目中，能有效避免因接口不一致导致的协作问题。