Python 设计模式：迭代模式

1. 什么是迭代模式

迭代模式（Iterator Pattern）是一种行为型设计模式，它提供了一种方法来顺序访问一个集合对象中的元素，而无需暴露该对象的内部表示。迭代模式允许客户端以统一的方式遍历不同类型的集合（如列表、集合、字典等），而不需要了解集合的具体实现细节。

迭代模式的主要作用包括：

1. 统一接口：提供一个统一的接口来遍历不同类型的集合，简化了客户端代码。

2. 隐藏内部结构：客户端不需要了解集合的内部实现细节，从而降低了代码的耦合度。

3. 支持多种集合：可以为不同类型的集合提供迭代器，使得它们可以使用相同的遍历方式。

4. 简化代码：通过使用迭代器，客户端代码变得更加简洁和易于理解。

2. Python 自带的迭代器和生成器

在 Python 中，迭代器和生成器是实现迭代模式的两个重要工具。它们提供了方便的方式来遍历集合，同时保持代码的简洁性和可读性。以下是对 Python 自带的迭代器和生成器的详细介绍。

2.1 迭代器

在 Python 中，迭代器是一个实现了 __iter__() 和 __next__() 方法的对象。迭代器可以用于遍历集合中的元素，而不需要暴露集合的内部结构。Python 的内置数据类型（如列表、元组、字典和集合）都可以被迭代。

示例：使用内置迭代器

# 使用列表作为迭代器
my_list = [1, 2, 3, 4, 5]

# 创建迭代器
iterator = iter(my_list)

# 遍历迭代器
while True:
    try:
        item = next(iterator)
        print(item)
    except StopIteration:
        break

1
2
3
4
5

在这个示例中，我们使用 iter() 函数创建了一个列表的迭代器，并使用 next() 函数逐个访问列表中的元素。当没有更多元素可供访问时，next() 函数会抛出 StopIteration 异常，表示迭代结束。

2.2 生成器

生成器是 Python 中一种特殊类型的迭代器，它使用 yield 关键字来生成值。生成器函数在调用时返回一个生成器对象，而不是立即计算并返回结果。每次调用生成器的 next() 方法时，函数会从上次返回的位置继续执行，直到遇到下一个 yield 语句。

示例：使用生成器

def number_generator(n):
    for i in range(n):
        yield i

# 创建生成器
gen = number_generator(5)

# 遍历生成器
for number in gen:
    print(number)

0
1
2
3
4

在这个示例中，number_generator 函数是一个生成器函数，它使用 yield 关键字逐个生成数字。每次调用 next() 或使用 for 循环遍历生成器时，函数会继续执行，直到遇到下一个 yield 语句。

2.3 生成器的优势

1. 内存效率：生成器按需生成值，而不是一次性生成所有值，因此在处理大型数据集时，生成器可以显著减少内存使用。

2. 简洁性：生成器函数的代码通常比使用迭代器类的代码更简洁，易于理解和维护。

3. 惰性求值：生成器支持惰性求值，只有在需要时才计算值，这使得它们在处理流数据或无限序列时非常有用。

2.4 迭代器和生成器的优势示例

示例 1：处理大型数据集

在处理大型数据集时，使用生成器可以显著减少内存使用。假设我们需要读取一个大型文件并逐行处理，而不是一次性将整个文件加载到内存中。

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

# 使用生成器逐行读取文件
for line in read_large_file('large_file.txt'):
    print(line)

在这个示例中，read_large_file 函数是一个生成器，它逐行读取文件内容。这样做的好处是，只有在需要时才会读取文件的每一行，从而避免了将整个文件加载到内存中。

示例 2：无限序列生成

生成器非常适合生成无限序列，例如斐波那契数列。使用生成器可以轻松实现这一点，而不需要预先计算所有的值。

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 使用生成器生成斐波那契数列
fib_gen = fibonacci()
for _ in range(10):
    print(next(fib_gen))

在这个示例中，fibonacci 函数是一个生成器，它无限生成斐波那契数列的值。客户端代码可以根据需要调用 next() 来获取下一个值，而不需要事先计算所有的值。

示例 3：流数据处理

在处理流数据（如实时传感器数据或网络数据）时，生成器可以提供一种高效的方式来处理数据流。以下是一个简单的示例，模拟从传感器读取数据。

import random
import time

def sensor_data_stream():
    while True:
        yield random.uniform(20.0, 30.0)  # 模拟传感器数据
        time.sleep(1)  # 每秒生成一个数据点

# 使用生成器处理传感器数据
for data in sensor_data_stream():
    print(f"Sensor data: {data:.2f}")

在这个示例中，sensor_data_stream 函数是一个生成器，它模拟从传感器读取数据。每次调用生成器时，它会生成一个新的随机数据点。客户端代码可以实时处理这些数据，而不需要等待所有数据都准备好。

3. 自定义迭代模式示例 1：树形结构的迭代器

在实际项目中，自定义迭代模式可以用于处理复杂的数据结构，例如树形结构、图形结构或其他自定义集合。以下是一个稍微复杂一点的示例，展示如何使用迭代模式来遍历树形结构，并体现迭代模式的优势。

假设我们有一个表示组织结构的树形结构，每个节点代表一个员工，包含员工的姓名和下属员工。我们希望能够遍历这个组织结构，获取所有员工的姓名。

class EmployeeNode:
    def __init__(self, name):
        self.name = name
        self.subordinates = []

    def add_subordinate(self, employee):
        self.subordinates.append(employee)


class EmployeeIterator:
    def __init__(self, root):
        self.stack = [root]  # 使用栈来存储待遍历的节点

    def __iter__(self):
        return self

    def __next__(self):
        if not self.stack:
            raise StopIteration
        current = self.stack.pop()  # 获取当前节点
        self.stack.extend(reversed(current.subordinates))  # 将下属节点压入栈中
        return current.name


# 创建组织结构
ceo = EmployeeNode("CEO")
cto = EmployeeNode("CTO")
cfo = EmployeeNode("CFO")
dev1 = EmployeeNode("Developer 1")
dev2 = EmployeeNode("Developer 2")
fin1 = EmployeeNode("Finance 1")

# 构建树形结构
ceo.add_subordinate(cto)
ceo.add_subordinate(cfo)
cto.add_subordinate(dev1)
cto.add_subordinate(dev2)
cfo.add_subordinate(fin1)

# 使用迭代器遍历组织结构
if __name__ == "__main__":
    print("Employee List:")
    for employee in EmployeeIterator(ceo):
        print(employee)

Employee List:
CEO
CTO
Developer 1
Developer 2
CFO
Finance 1

在这个示例中，我们定义了一个 EmployeeNode 类来表示组织结构中的每个员工节点。每个节点可以有多个下属员工。我们还定义了一个 EmployeeIterator 类，它实现了迭代器接口，允许我们遍历整个组织结构。

• EmployeeIterator 类 ：使用栈来存储待遍历的节点。每次调用 __next__() 方法时，获取当前节点并将其下属节点压入栈中，从而实现深度优先遍历。

1. 统一接口 ：通过 EmployeeIterator，我们可以使用统一的方式遍历组织结构，而不需要关心树的具体实现细节。

2. 隐藏内部结构：客户端代码不需要了解树的内部结构，只需使用迭代器即可获取员工姓名。

3. 支持多种集合：如果我们需要支持其他类型的集合（例如图形结构），只需实现相应的迭代器，而不需要修改客户端代码。

4. 简化代码：使用迭代器使得遍历逻辑更加简洁，客户端代码清晰易懂。

4. 自定义迭代模式示例 2：图形结构的迭代器

在实际项目中，图形结构（如社交网络、网页链接等）也常常需要使用迭代模式来遍历。以下是一个示例，展示如何使用迭代模式来遍历图形结构，并体现迭代模式的优势。

假设我们有一个表示社交网络的图形结构，每个节点代表一个用户，包含用户的姓名和朋友列表。我们希望能够遍历这个社交网络，获取所有用户的姓名。

class UserNode:
    def __init__(self, name):
        self.name = name
        self.friends = []

    def add_friend(self, friend):
        self.friends.append(friend)


class UserIterator:
    def __init__(self, root, max_depth):
        self.stack = [(root, 0)]  # 使用栈存储待遍历的节点和当前深度
        self.visited = set()  # 记录已访问的节点
        self.max_depth = max_depth  # 最大深度

    def __iter__(self):
        return self

    def __next__(self):
        while self.stack:
            current, depth = self.stack.pop()  # 获取当前节点和深度
            if current not in self.visited:
                self.visited.add(current)  # 标记为已访问
                if depth < self.max_depth:  # 检查深度限制
                    self.stack.extend((friend, depth + 1) for friend in current.friends)  # 将朋友节点压入栈中
                return current.name
        raise StopIteration


# 创建社交网络
alice = UserNode("Alice")
bob = UserNode("Bob")
charlie = UserNode("Charlie")
dave = UserNode("Dave")

# 构建图形结构
alice.add_friend(bob)
alice.add_friend(charlie)
bob.add_friend(dave)
charlie.add_friend(dave)

# 使用迭代器遍历社交网络，限制到1级好友
if __name__ == "__main__":
    print("User List (up to 1 level):")
    for user in UserIterator(alice, max_depth=1):
        print(user)

    print("\nUser List (up to 2 levels):")
    for user in UserIterator(alice, max_depth=2):
        print(user)

User List (up to 1 level):
Alice
Bob
Charlie

User List (up to 2 levels):
Alice
Bob
Dave
Charlie

1. UserNode 类：表示社交网络中的每个用户节点。每个节点可以有多个朋友。
2. UserIterator 类 ：实现了迭代器接口，允许我们遍历整个社交网络。它使用栈来存储待遍历的节点，并使用集合 visited 来记录已访问的节点，以避免重复访问。max_depth 参数用于限制遍历的层级。
3. 社交网络构建 ：创建了一个简单的社交网络，其中 Alice 是根节点，Bob 和 Charlie 是她的朋友，Dave 是 Bob 和 Charlie 的朋友。
4. 遍历示例 ：使用 UserIterator 遍历社交网络，分别限制到 1 级和 2 级好友。