Python中的迭代器模式与自定义可迭代对象实现

描述：
迭代器模式是Python中一个重要的设计模式，它允许我们按顺序访问聚合对象的元素，而不暴露其底层表示。Python通过实现迭代器协议来支持这种模式，这个协议包括__iter__()和__next__()方法。理解如何创建自定义的可迭代对象和迭代器对于处理大型数据集、实现惰性计算和创建复杂的数据结构非常重要。

知识点详解：

1. 迭代器协议的基本概念

Python的迭代器协议由两个方法组成：

• __iter__()：返回迭代器对象自身
• __next__()：返回容器的下一个值，当没有更多元素时抛出StopIteration异常

可迭代对象是实现了__iter__()方法的任何对象，它可以返回一个迭代器。迭代器是实现了__iter__()和__next__()方法的对象。

# Python内置的迭代器示例
my_list = [1, 2, 3]
# 获取迭代器
iterator = iter(my_list)  # 等价于 my_list.__iter__()
# 使用迭代器
print(next(iterator))  # 1，等价于 iterator.__next__()
print(next(iterator))  # 2
print(next(iterator))  # 3
# print(next(iterator))  # 抛出 StopIteration

2. 自定义迭代器的实现步骤

步骤1：创建简单的自定义迭代器

我们先创建一个简单的计数器迭代器：

class CounterIterator:
    """自定义迭代器类"""
    def __init__(self, start, end):
        self.current = start
        self.end = end
    
    def __iter__(self):
        """返回迭代器自身"""
        return self
    
    def __next__(self):
        """返回下一个值"""
        if self.current < self.end:
            result = self.current
            self.current += 1
            return result
        else:
            # 没有更多元素时抛出StopIteration
            raise StopIteration

# 使用自定义迭代器
counter = CounterIterator(1, 4)
for num in counter:
    print(num)  # 输出: 1, 2, 3

步骤2：分离可迭代对象和迭代器

在实际应用中，通常将可迭代对象和迭代器分离，这样可以多次迭代同一数据：

class Counter:
    """可迭代对象"""
    def __init__(self, start, end):
        self.start = start
        self.end = end
    
    def __iter__(self):
        """返回一个新的迭代器实例"""
        return CounterIterator(self.start, self.end)

# 现在可以多次迭代
counter = Counter(1, 4)
for num in counter:
    print(num)  # 1, 2, 3
for num in counter:  # 可以再次迭代
    print(num)  # 1, 2, 3

步骤3：使用生成器函数简化实现

Python提供了更简洁的方式——使用生成器函数：

class Counter:
    def __init__(self, start, end):
        self.start = start
        self.end = end
    
    def __iter__(self):
        """生成器函数自动创建迭代器"""
        current = self.start
        while current < self.end:
            yield current
            current += 1

# 更简洁的实现
counter = Counter(1, 4)
for num in counter:
    print(num)  # 1, 2, 3

3. 实现一个完整的数据结构迭代器

让我们实现一个更实用的例子——一个支持迭代的自定义链表：

class LinkedListNode:
    def __init__(self, value):
        self.value = value
        self.next = None

class LinkedList:
    """自定义链表，支持迭代"""
    def __init__(self):
        self.head = None
        self.tail = None
    
    def append(self, value):
        """添加节点"""
        new_node = LinkedListNode(value)
        if not self.head:
            self.head = new_node
            self.tail = new_node
        else:
            self.tail.next = new_node
            self.tail = new_node
    
    def __iter__(self):
        """返回链表迭代器"""
        return LinkedListIterator(self.head)

class LinkedListIterator:
    """链表迭代器"""
    def __init__(self, start_node):
        self.current = start_node
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current is None:
            raise StopIteration
        value = self.current.value
        self.current = self.current.next
        return value

# 使用自定义链表
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)

for value in linked_list:
    print(value)  # 1, 2, 3

4. 实现反向迭代器

有时候我们需要支持反向迭代：

class BidirectionalList:
    def __init__(self, data):
        self.data = list(data)
    
    def __iter__(self):
        """正向迭代"""
        for item in self.data:
            yield item
    
    def __reversed__(self):
        """反向迭代"""
        for i in range(len(self.data)-1, -1, -1):
            yield self.data[i]

# 测试反向迭代
my_list = BidirectionalList([1, 2, 3, 4])
print("正向迭代:")
for item in my_list:
    print(item)  # 1, 2, 3, 4

print("\n反向迭代:")
for item in reversed(my_list):
    print(item)  # 4, 3, 2, 1

5. 迭代器的高级应用：惰性计算

迭代器非常适合实现惰性计算，只在需要时生成值：

class FibonacciIterator:
    """斐波那契数列迭代器"""
    def __init__(self, max_value=float('inf')):
        self.max_value = max_value
        self.a, self.b = 0, 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.a > self.max_value:
            raise StopIteration
        result = self.a
        self.a, self.b = self.b, self.a + self.b
        return result

# 惰性生成斐波那契数列
fib = FibonacciIterator(100)
for num in fib:
    if num > 20:  # 只计算到20左右
        break
    print(num)  # 0, 1, 1, 2, 3, 5, 8, 13

6. 迭代器协议的内置支持

Python的for循环实际上是这样工作的：

# for循环的内部机制
def explain_for_loop(iterable):
    # 获取迭代器
    iterator = iter(iterable)
    while True:
        try:
            # 获取下一个元素
            item = next(iterator)
            # 执行循环体代码
            print(f"处理元素: {item}")
        except StopIteration:
            # 迭代完成，退出循环
            break

# 测试
explain_for_loop([1, 2, 3])

7. 迭代器的实际应用场景

1. 处理大文件：逐行读取，不一次性加载到内存
2. 无限序列：如计数器、随机数生成器
3. 数据库查询结果：逐行获取查询结果
4. 流数据处理：网络请求、传感器数据等
5. 管道操作：多个处理步骤串联

关键要点总结：

• 迭代器协议由__iter__()和__next__()方法定义
• 可迭代对象返回迭代器，迭代器产生值
• 分离可迭代对象和迭代器允许多次迭代
• 生成器函数是创建迭代器的简洁方式
• 迭代器支持惰性计算，节省内存
• Python的for循环是基于迭代器协议实现的

通过实现自定义迭代器，你可以创建更灵活、更高效的数据处理组件，特别是在处理大数据集或实现复杂的数据流处理时。