Python的访问者模式：如何使用访问者模式分离算法和对象结构，实现复杂操作。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python 中的访问者模式：分离算法与对象结构

大家好，今天我们要深入探讨一种强大的设计模式：访问者模式。它能帮助我们优雅地将算法从它们操作的对象结构中分离出来，从而实现更灵活、可维护的代码。我们将通过具体例子，循序渐进地理解访问者模式的原理和应用。

问题：当操作与对象类型紧密耦合时

想象一下，我们有一个表示公司组织结构的类体系。其中包含 Employee （员工）基类，以及 Developer (开发人员)、 Manager (经理) 等子类。现在，我们需要对这个组织结构执行一些操作，例如：

计算所有员工的薪水总和。
给所有开发者增加代码行数统计。
打印出所有经理的汇报对象。

最直接的方式是在 Employee 类及其子类中添加相应的方法。例如，在 Employee 中添加 calculate_salary() 方法，在 Developer 中添加 add_lines_of_code() 方法。

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def calculate_salary(self):
        return self.salary

class Developer(Employee):
    def __init__(self, name, salary, lines_of_code):
        super().__init__(name, salary)
        self.lines_of_code = lines_of_code

    def add_lines_of_code(self, lines):
        self.lines_of_code += lines

class Manager(Employee):
    def __init__(self, name, salary, reports):
        super().__init__(name, salary)
        self.reports = reports # 下属员工列表

这种做法看起来简单，但存在几个问题：

紧耦合： 操作（例如 calculate_salary()、add_lines_of_code()）与对象类型（Employee、Developer）紧密耦合。如果我们要添加新的操作，就需要修改 Employee 类及其子类，这违反了开闭原则（对扩展开放，对修改关闭）。
代码重复： 不同的操作可能需要访问相同的对象属性。例如，calculate_salary() 和 print_employee_info() 都需要访问 salary 属性。这会导致代码重复。
可维护性差： 随着操作数量的增加，Employee 类及其子类会变得越来越臃肿，难以维护。

访问者模式：解耦操作与对象结构

访问者模式通过将操作从对象结构中分离出来，解决了上述问题。它包含以下几个关键角色：

Element (元素): 定义 accept() 方法，接受一个访问者。在我们的例子中，Employee 类及其子类就是元素。
Visitor (访问者): 定义一个访问每个元素类型的 visit() 方法。每个具体访问者实现一种特定的操作。
ConcreteElement (具体元素): 实现 Element 接口，并实现 accept() 方法，将自身传递给访问者。例如，Developer 和 Manager 是具体元素。
ConcreteVisitor (具体访问者): 实现 Visitor 接口，定义对每种元素类型的操作。例如，SalaryCalculator 和 CodeLineCounter 是具体访问者。
ObjectStructure (对象结构): 包含元素的集合，并提供遍历元素的方法。例如，一个 Company 类可以包含所有员工的列表。

核心思想：

每个元素类（Employee，Developer，Manager）都有一个 accept() 方法。
accept() 方法接受一个 Visitor 对象作为参数。
在 accept() 方法内部，元素调用访问者的 visit() 方法，并将自身作为参数传递给访问者。
访问者根据传入的元素类型，执行相应的操作。

代码实现

让我们用 Python 实现访问者模式来解决前面提到的公司组织结构问题。

# Element 接口
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def accept(self, visitor):
        visitor.visit(self) # 默认行为，可以被子类重写

    def get_name(self):
        return self.name

    def get_salary(self):
        return self.salary

# ConcreteElement
class Developer(Employee):
    def __init__(self, name, salary, lines_of_code):
        super().__init__(name, salary)
        self.lines_of_code = lines_of_code

    def get_lines_of_code(self):
        return self.lines_of_code

    def accept(self, visitor):
        visitor.visit(self)

# ConcreteElement
class Manager(Employee):
    def __init__(self, name, salary, reports):
        super().__init__(name, salary)
        self.reports = reports

    def get_reports(self):
        return self.reports

    def accept(self, visitor):
        visitor.visit(self)

# Visitor 接口
class Visitor:
    def visit(self, employee):
        pass  # 默认行为，需要被子类重写

# ConcreteVisitor：计算薪水总和
class SalaryCalculator(Visitor):
    def __init__(self):
        self.total_salary = 0

    def visit(self, employee):
        self.total_salary += employee.get_salary()

    def get_total_salary(self):
        return self.total_salary

# ConcreteVisitor：统计代码行数
class CodeLineCounter(Visitor):
    def __init__(self):
        self.total_lines = 0

    def visit(self, employee):
        if isinstance(employee, Developer):
            self.total_lines += employee.get_lines_of_code()

    def get_total_lines(self):
        return self.total_lines

# ConcreteVisitor：打印员工信息
class EmployeeInfoPrinter(Visitor):
    def visit(self, employee):
        print(f"Name: {employee.get_name()}, Salary: {employee.get_salary()}")
        if isinstance(employee, Developer):
            print(f"  Lines of code: {employee.get_lines_of_code()}")
        elif isinstance(employee, Manager):
            print(f"  Reports to: {[report.get_name() for report in employee.get_reports()]}")

# ObjectStructure
class Company:
    def __init__(self):
        self.employees = []

    def add_employee(self, employee):
        self.employees.append(employee)

    def accept(self, visitor):
        for employee in self.employees:
            employee.accept(visitor)

使用示例：

# 创建员工
john = Developer("John", 50000, 10000)
jane = Manager("Jane", 80000, [])
mike = Developer("Mike", 60000, 15000)
jane.reports = [john, mike]

# 创建公司并添加员工
company = Company()
company.add_employee(john)
company.add_employee(jane)
company.add_employee(mike)

# 计算薪水总和
salary_calculator = SalaryCalculator()
company.accept(salary_calculator)
print(f"Total salary: {salary_calculator.get_total_salary()}")  # 输出: Total salary: 190000

# 统计代码行数
code_line_counter = CodeLineCounter()
company.accept(code_line_counter)
print(f"Total lines of code: {code_line_counter.get_total_lines()}")  # 输出: Total lines of code: 25000

# 打印员工信息
employee_info_printer = EmployeeInfoPrinter()
company.accept(employee_info_printer)
# 输出:
# Name: John, Salary: 50000
#   Lines of code: 10000
# Name: Jane, Salary: 80000
#   Reports to: ['John', 'Mike']
# Name: Mike, Salary: 60000
#   Lines of code: 15000

访问者模式的优势

解耦算法和对象结构： 访问者模式将算法从它们操作的对象结构中分离出来，使得算法可以独立地变化，而不会影响对象结构。
增加新的操作变得容易： 要添加新的操作，只需要创建一个新的访问者类即可，而无需修改现有的元素类。这符合开闭原则。
聚集相关操作： 访问者模式可以将相关的操作聚集到一个类中，使得代码更易于理解和维护。
支持动态类型检查： 访问者模式可以在运行时根据元素的类型选择执行相应的操作。

访问者模式的缺点

增加新的元素类型困难： 如果需要添加新的元素类型，则需要修改所有的访问者类，为新的元素类型添加 visit() 方法。
可能破坏封装： 访问者需要访问元素的内部状态才能执行操作，这可能会破坏元素的封装性。在上面的例子中，我们使用了 get_salary()， get_lines_of_code()和 get_reports()方法，如果访问者需要访问更多的私有属性，那么需要修改元素类来提供访问接口，可能会破坏封装。
代码复杂性增加： 访问者模式引入了额外的类和接口，可能会增加代码的复杂性。

适用场景

访问者模式适用于以下场景：

对象结构稳定，但需要对其执行多种不同的操作。 例如，编译器需要对抽象语法树执行类型检查、代码生成等多种操作。
需要在运行时根据对象的类型选择执行不同的操作。 例如，图形编辑器需要根据图形的类型选择不同的绘制算法。
需要将相关的操作聚集到一个类中。 例如，编译器可以将所有的优化操作聚集到一个优化器类中。

访问者模式与其他设计模式的比较

模式	目的	优点	缺点
访问者模式	将算法与对象结构分离，允许在不修改对象结构的情况下添加新的操作。	1. 解耦算法和对象结构。 2. 容易增加新的操作。 3. 可以聚集相关操作。 4. 支持动态类型检查。	1. 增加新的元素类型困难。 2. 可能破坏封装。 3. 代码复杂性增加。
策略模式	定义一系列算法，并将每个算法封装成一个独立的类，使得它们可以互相替换。	1. 定义了一系列可重用的算法。 2. 简化了单元测试。 3. 避免了使用多重条件转移语句。	1. 客户端必须知道所有的策略。 2. 可能产生很多策略类。
迭代器模式	提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。	1. 支持以不同的方式遍历一个聚合对象。 2. 简化了聚合类的接口。 3. 可以在同一个聚合对象上进行多次遍历。	1. 增加了类的数量。
模板方法模式	定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。	1. 定义了一个算法的骨架。 2. 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 3. 提高了代码的复用性。	1. 必须遵守模板方法的约束。 2. 增加了类的数量。

一个更复杂的例子：表达式求值

让我们考虑一个更复杂的例子：表达式求值。假设我们有一个表达式树，其中包含以下节点类型：

Number (数字)
Add (加法)
Subtract (减法)

我们需要对这个表达式树进行求值。使用访问者模式，我们可以将求值算法从表达式树的结构中分离出来。

# 表达式树节点接口
class Expression:
    def accept(self, visitor):
        pass

# 具体表达式节点
class Number(Expression):
    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

    def accept(self, visitor):
        visitor.visit(self)

# 具体表达式节点
class Add(Expression):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def get_left(self):
        return self.left

    def get_right(self):
        return self.right

    def accept(self, visitor):
        visitor.visit(self)

# 具体表达式节点
class Subtract(Expression):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def get_left(self):
        return self.left

    def get_right(self):
        return self.right

    def accept(self, visitor):
        visitor.visit(self)

# 访问者接口
class ExpressionVisitor:
    def visit(self, expression):
        pass

# 具体访问者：求值器
class Evaluator(ExpressionVisitor):
    def __init__(self):
        self.result = 0

    def visit(self, expression):
        if isinstance(expression, Number):
            self.result = expression.get_value()
        elif isinstance(expression, Add):
            expression.get_left().accept(self)
            left_value = self.result
            expression.get_right().accept(self)
            right_value = self.result
            self.result = left_value + right_value
        elif isinstance(expression, Subtract):
            expression.get_left().accept(self)
            left_value = self.result
            expression.get_right().accept(self)
            right_value = self.result
            self.result = left_value - right_value

    def get_result(self):
        return self.result

# 构建表达式树
expression = Add(Number(10), Subtract(Number(5), Number(2)))

# 求值
evaluator = Evaluator()
expression.accept(evaluator)
print(f"Result: {evaluator.get_result()}")  # 输出: Result: 13

在这个例子中，Evaluator 负责遍历表达式树并计算结果。如果我们要添加新的操作，例如打印表达式树，只需要创建一个新的访问者类即可，而无需修改表达式树的结构。

更灵活的应用：双重分发

在上面的例子中，我们使用了 isinstance() 函数来判断元素的类型。这在一定程度上破坏了多态性。一种更灵活的方式是使用双重分发 (Double Dispatch)。

在双重分发中，accept() 方法会调用访问者的 visit() 方法，并将自身作为参数传递给访问者。访问者的 visit() 方法会根据参数的类型，调用相应的处理方法。

# Element 接口
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def accept(self, visitor):
        visitor.visit(self) # 默认行为，可以被子类重写

    def get_name(self):
        return self.name

    def get_salary(self):
        return self.salary

# ConcreteElement
class Developer(Employee):
    def __init__(self, name, salary, lines_of_code):
        super().__init__(name, salary)
        self.lines_of_code = lines_of_code

    def get_lines_of_code(self):
        return self.lines_of_code

    def accept(self, visitor):
        visitor.visit_developer(self) # 调用访问者特定的方法

# ConcreteElement
class Manager(Employee):
    def __init__(self, name, salary, reports):
        super().__init__(name, salary)
        self.reports = reports

    def get_reports(self):
        return self.reports

    def accept(self, visitor):
        visitor.visit_manager(self) # 调用访问者特定的方法

# Visitor 接口
class Visitor:
    def visit_developer(self, developer):
        pass

    def visit_manager(self, manager):
        pass

# ConcreteVisitor：计算薪水总和
class SalaryCalculator(Visitor):
    def __init__(self):
        self.total_salary = 0

    def visit_developer(self, developer):
        self.total_salary += developer.get_salary()

    def visit_manager(self, manager):
        self.total_salary += manager.get_salary()

    def get_total_salary(self):
        return self.total_salary

# ConcreteVisitor：统计代码行数
class CodeLineCounter(Visitor):
    def __init__(self):
        self.total_lines = 0

    def visit_developer(self, developer):
        self.total_lines += developer.get_lines_of_code()

    def visit_manager(self, manager):
        pass # 经理没有代码行数

# ConcreteVisitor：打印员工信息
class EmployeeInfoPrinter(Visitor):
    def visit_developer(self, developer):
        print(f"Name: {developer.get_name()}, Salary: {developer.get_salary()}")
        print(f"  Lines of code: {developer.get_lines_of_code()}")

    def visit_manager(self, manager):
        print(f"Name: {manager.get_name()}, Salary: {manager.get_salary()}")
        print(f"  Reports to: {[report.get_name() for report in manager.get_reports()]}")

# ObjectStructure
class Company:
    def __init__(self):
        self.employees = []

    def add_employee(self, employee):
        self.employees.append(employee)

    def accept(self, visitor):
        for employee in self.employees:
            employee.accept(visitor)

在这个版本中，Developer 类的 accept() 方法调用 visitor.visit_developer(self)，而 Manager 类的 accept() 方法调用 visitor.visit_manager(self)。这样，访问者就可以根据传入的元素类型，调用相应的处理方法，而无需使用 isinstance() 函数。

核心要点回顾

访问者模式的核心在于将算法从对象结构中分离出来，从而提高代码的灵活性和可维护性。通过定义 Element 和 Visitor 接口，以及具体的实现类，我们可以轻松地添加新的操作，而无需修改现有的对象结构。双重分发是一种更灵活的实现方式，可以避免使用 isinstance() 函数，提高代码的多态性。

总结

访问者模式是一种强大的设计模式，它通过将算法从对象结构中分离出来，实现了更灵活、可维护的代码。虽然它可能会增加代码的复杂性，但在合适的场景下，可以带来显著的优势。理解访问者模式的原理和应用，可以帮助我们更好地设计和构建复杂的软件系统。