class FileNode:    def __init__(self, name, is_directory=False):        self.name = name        self.is_directory = is_directory        self.children = []  # 如果是目录，包含子节点

# 糟糕的做法：遍历逻辑和树结构耦合在一起def print_all_files(node):    if not node.is_directory:        print(node.name)    else:        for child in node.children:            print_all_files(child)

class MyIterator:    def __iter__(self):        """返回迭代器对象自身"""        return self    def __next__(self):        """返回下一个元素，没有则抛出 StopIteration"""        # ... 返回下一个值，或者抛出 StopIteration        pass

# 这行代码...for item in collection:    print(item)# ... 等价于下面的逻辑：_iterator = iter(collection)  # 调用 collection.__iter__()while True:    try:        item = next(_iterator)  # 调用 _iterator.__next__()        print(item)    except StopIteration:        break

# 列表、元组、字符串——基础可迭代对象for char in "Python":    print(char)# 字典——遍历键、值、键值对for key, value in {"a": 1, "b": 2}.items():    print(key, value)# 文件对象——逐行读取with open("data.txt", "r", encoding="utf-8") as f:    for line in f:  # 文件对象本身就是迭代器        print(line.strip())# 生成器表达式squares = (x**2 for x in range(10))for sq in squares:    print(sq)

from collections import dequeclass FileNode:    """文件系统节点——聚合对象"""    def __init__(self, name, is_directory=False):        self.name = name        self.is_directory = is_directory        self.children = []    def add_child(self, node):        self.children.append(node)    def __iter__(self):        """返回默认的深度优先迭代器"""        return DepthFirstIterator(self)class DepthFirstIterator:    """深度优先迭代器"""    def __init__(self, root):        self._stack = [root]    def __iter__(self):        return self    def __next__(self):        if not self._stack:            raise StopIteration        # 弹出栈顶节点        node = self._stack.pop()        # 将子节点压入栈（逆序压入，保证正序弹出）        if node.is_directory:            for child in reversed(node.children):                self._stack.append(child)        return nodeclass BreadthFirstIterator:    """广度优先迭代器——同样的聚合对象，不同的遍历方式"""    def __init__(self, root):        self._queue = deque([root])    def __iter__(self):        return self    def __next__(self):        if not self._queue:            raise StopIteration        # 从队列头部取出        node = self._queue.popleft()        # 将子节点加入队列尾部        if node.is_directory:            for child in node.children:                self._queue.append(child)        return node

# 构建文件系统树root = FileNode("root", is_directory=True)root.add_child(FileNode("file1.txt"))folder_a = FileNode("folder_a", is_directory=True)folder_a.add_child(FileNode("file2.txt"))folder_a.add_child(FileNode("file3.txt"))root.add_child(folder_a)# 使用默认的深度优先迭代器print("=== 深度优先 ===")for node in root:    print(node.name)# 使用广度优先迭代器print("\n=== 广度优先 ===")for node in BreadthFirstIterator(root):    print(node.name)

=== 深度优先 ===rootfolder_afile3.txtfile2.txtfile1.txt=== 广度优先 ===rootfile1.txtfolder_afile2.txtfile3.txt

class PaginatedQuery:    """分页查询迭代器——隐藏分页细节，对外表现为连续的数据流"""    def __init__(self, db_connection, query, page_size=100):        self._db = db_connection        self._query = query        self._page_size = page_size        self._current_page = 0        self._buffer = []        self._buffer_index = 0        self._exhausted = False    def __iter__(self):        return self    def __next__(self):        # 如果缓冲区还有数据，直接返回        if self._buffer_index < len(self._buffer):            result = self._buffer[self._buffer_index]            self._buffer_index += 1            return result        # 缓冲区空了，需要加载下一页        if self._exhausted:            raise StopIteration        self._load_next_page()        # 加载后仍然没有数据，说明已耗尽        if not self._buffer:            self._exhausted = True            raise StopIteration        # 返回新加载的第一个数据        result = self._buffer[self._buffer_index]        self._buffer_index += 1        return result    def _load_next_page(self):        """从数据库加载下一页数据"""        offset = self._current_page * self._page_size        page_query = f"{self._query} LIMIT {self._page_size} OFFSET {offset}"        # 模拟数据库查询（实际中替换为真实查询）        # self._buffer = self._db.execute(page_query).fetchall()        self._buffer = self._mock_query(page_query)        self._buffer_index = 0        self._current_page += 1        # 如果返回的数据少于 page_size，说明是最后一页        if len(self._buffer) < self._page_size:            self._exhausted = True    def _mock_query(self, query):        """模拟数据查询，实际使用时删除此方法"""        import random        if self._current_page > 5:  # 模拟总共 600 条数据            return []        return [f"record_{self._current_page * self._page_size + i}"                for i in range(self._page_size)]# 使用示例db = None  # 实际的数据库连接query = PaginatedQuery(db, "SELECT * FROM users WHERE status = 'active'")# 客户端代码完全感知不到分页的存在！for record in query:    print(record)    # 处理每一条记录...

class FileNode:    def __init__(self, name, is_directory=False):        self.name = name        self.is_directory = is_directory        self.children = []    def add_child(self, node):        self.children.append(node)    def depth_first(self):        """使用生成器实现深度优先遍历"""        yield self  # 先返回自身        if self.is_directory:            for child in self.children:                yield from child.depth_first()  # 递归遍历子节点    def breadth_first(self):        """使用生成器实现广度优先遍历"""        from collections import deque        queue = deque([self])        while queue:            node = queue.popleft()            yield node            if node.is_directory:                queue.extend(node.children)

# 无论底层是列表、树、图还是数据库，都使用相同的 for 循环遍历for item in collection:    process(item)

# 处理 10GB 的日志文件，无需一次性读入内存with open("huge.log", "r", encoding="utf-8") as f:    for line in f:  # 每次只读一行        if "ERROR" in line:            print(line)

def fibonacci():    """无限斐波那契数列"""    a, b = 0, 1    while True:        yield a        a, b = b, a + b# 取前 10 个fib = fibonacci()for _ in range(10):    print(next(fib))

<br class="Apple-interchange-newline"><div></div>class TreeNode:    def __iter__(self):        return self.depth_first()    def depth_first(self):        """返回深度优先迭代器"""        ...    def breadth_first(self):        """返回广度优先迭代器"""        ...

iterator = iter([1, 2, 3])print(list(iterator))  # [1, 2, 3]print(list(iterator))  # [] —— 已经耗尽了！

numbers = [1, 2, 3, 4, 5]for n in numbers:    if n % 2 == 0:        numbers.remove(n)  # 危险！可能导致不可预期的行为

import itertools# 无限计数器for i in itertools.count(start=10, step=2):    if i > 20:        break    print(i)  # 10, 12, 14, 16, 18, 20# 循环迭代for item in itertools.cycle(["A", "B", "C"]):    # 无限循环 A, B, C    pass# 组合colors = ["红", "绿", "蓝"]for combo in itertools.combinations(colors, 2):    print(combo)  # ('红', '绿'), ('红', '蓝'), ('绿', '蓝')