访客模式（从下到上）答案

【问题标题】：Visitor pattern (from bottom to top)访客模式（从下到上）
【发布时间】：2013-09-10 13:22:06
【问题描述】：

在我回答关于visitor pattern in python 的具体问题之前，请考虑下面的（示例）代码：

class Node:
    def __init__(self):
        self.children = []
    def add(self, node):
        self.children.append(node)
    def check(self):
        print("Node")
        return True
    def accept(self, visitor):
        visitor.visit(self)

class NodeA(Node):
    def check(self):
        print("NodeA")
        return True
class NodeB(Node):
    def check(self):
        print("NodeB")
        return True


class NodeA_A(NodeA):
    def check(self):
        print("NodeA_A")
        return True
class NodeA_B(NodeA):
    def check(self):
        print("NodeA_B")
        return True

class NodeA_A_A(NodeA_A):
    def check(self):
        print("NodeA_A_A")
        return False

class NodeRunner:
    def visit(self, node):
        node.check()
        if len(node.children) > 0:
            for child in node.children:
                child.accept(self)

if __name__ == "__main__":
    n = Node()
    n1 = NodeA()
    n2 = NodeB()
    n11 = NodeA_A()
    n12 = NodeA_B()
    n111 = NodeA_A_A()

    n.add(n1)
    n.add(n2)

    n1.add(n11)
    n1.add(n12)

    n11.add(n111)

    v = NodeRunner()
    v.visit(n)

当我运行它时，它会迭代地遍历所有节点类并返回以下内容：

Node
NodeA
NodeA_A
NodeA_A_A
NodeA_B
NodeB

这一切都很好，但现在是我的问题。您可能已经注意到每个check-method 都返回一个布尔值（假设这实际上是一个复杂的方法）。

在上面的示例中，Node 类中的每个check 方法都返回True，但NodeA_A_A 除外。我想在访问期间以某种方式存储它，这样我就可以使所有基类失败。

这很难解释，我来说明一下：

如果NodeA_A_A返回False，那么我想失败NodeA_A, NodeA and Node。不管这些类返回什么。
如果NodeB返回False，那么我想失败Node。不管其他类返回什么。

因此，如果child-class 在某处失败（检查方法返回False），我希望它的所有基类都失败。

有人有什么想法吗？

【问题讨论】：

base classes 是什么意思？是children 还是parents 还是真正的班级？
你的预期输出是什么？
@User 'Bases Classes' 我的意思是被继承的类！例如NodeA 继承自 Node，Node 是它的基类。
它真的与访问者/复合模式有关吗？好的，您拥有复合结构，并使用访问者添加操作。但对我来说，您真正需要的另外是使行为依赖于某些“共享”状态的状态模式。
我一直将访问者模式视为穷人版本的多次调度（特别是双重调度）。您使用的不是Java 或C#，而是Python，它是动态的并且支持多方法（通过multimethods 或PEAK-rules）。那么，为什么要使用访问者呢？（PS 我也很高兴听到其他人对该主题的看法。我想不出在 Python 中使用访问者的充分理由，但我想了解是否有一个好的用例。 )

标签： python design-patterns python-2.7 visitor-pattern

【解决方案1】：

看来您要的不是访问者模式，而是如何实现深度优先搜索算法。这是我对您的问题的解决方案：

class Node:
    def __init__(self):
        self.children = []
    def add(self, node):
        self.children.append(node)
    def check(self):
        print("Node")
        return True
    def accept(self, visitor):
        return visitor.visit(self)

class NodeA(Node):
    def check(self):
        print("NodeA")
        return True
class NodeB(Node):
    def check(self):
        print("NodeB")
        return True


class NodeA_A(NodeA):
    def check(self):
        print("NodeA_A")
        return True
class NodeA_B(NodeA):
    def check(self):
        print("NodeA_B")
        return True

class NodeA_A_A(NodeA_A):
    def check(self):
        print("NodeA_A_A")
        return False

class NodeRunner:
    def visit(self, node):
        ret = True
        # visit all children
        for child in node.children:
            v = child.accept(self)
            if not v and ret:  # if some child not accepted, then we think that the parent node should also not be accepted
                ret = False

        # check the node
        if not node.check():
            ret = False
        return ret

if __name__ == "__main__":
    n = Node()
    n1 = NodeA()
    n2 = NodeB()
    n11 = NodeA_A()
    n12 = NodeA_B()
    n111 = NodeA_A_A()

    n.add(n1)
    n.add(n2)

    n1.add(n11)
    n1.add(n12)

    n11.add(n111)

    v = NodeRunner()
    print v.visit(n)

【讨论】：

嗨，这真的不是我想要的。您的代码甚至不会访问所有节点。我希望子节点设置其基类的结果，并且应该一直这样做。
@theAlse 所以你想让所有的节点都被访问，当某些子节点没有通过检查时，父节点的结果也会为假。我做对了吗？

【解决方案2】：

我使用访问者模式访问所有节点。一位访问者访问并运行所有节点，另一位访问者将结果冒泡。代码和输出如下：

class Node(object):
    def __init__(self):
        self.children = []
        self.result = None
    def add(self, node):
        self.children.append(node)
    def check(self):
        self.result = True
        print "Node: result:%s" % self.result
        return self.result
    def accept(self, visitor):
        visitor.visit(self)

class Node_A(Node):
    def __init__(self):
        super(Node_A, self).__init__()
    def check(self):
        self.result = True
        print "Node_A: result:%s" % self.result
        return self.result

class Node_A_A(Node_A):
    def __init__(self):
        super(Node_A_A, self).__init__()
    def check(self):
        self.result = True
        print "Node_A_A: result:%s" % self.result
        return self.result

class Node_A_B(Node_A):
    def __init__(self):
        super(Node_A_B, self).__init__()
    def check(self):
        self.result = True
        print "Node_A_B: result:%s" % self.result
        return self.result

class Node_A_A_A(Node_A_A):
    def __init__(self):
        super(Node_A_A_A, self).__init__()
    def check(self):
        self.result = True
        print "Node_A_A_A: result:%s" % self.result
        return self.result
class Node_A_A_B(Node_A_A):
    def __init__(self):
        super(Node_A_A_B, self).__init__()
    def check(self):
        self.result = False
        print "Node_A_A_B: result:%s" % self.result
        return self.result

class Node_A_B_A(Node_A_B):
    def __init__(self):
        super(Node_A_B_A, self).__init__()
    def check(self):
        self.result = True
        print "Node_A_B_A: result:%s" % self.result
        return self.result



class NodeRunner:
    def visit(self, node):
        if len(node.children) > 0:
            for child in node.children:
                child.accept(self)
        node.check()

class NodeChecker:
    def visit(self, node):
        results = []
        if len(node.children) > 0:
            for child in node.children:
                child.accept(self)
                results.append(child.result)
            node.result = all(results)


if __name__ == "__main__":
    node = Node()
    node_a = Node_A()
    node_a_a = Node_A_A()
    node_a_b = Node_A_B()

    node_a_a_a = Node_A_A_A()
    node_a_a_b = Node_A_A_B()

    node_a_b_a = Node_A_B_A()

    node.add(node_a)

    node_a.add(node_a_a)
    node_a_a.add(node_a_a_a)
    node_a_a.add(node_a_a_b)

    node_a.add(node_a_b)
    node_a_b.add(node_a_b_a)


    print("-------------------")
    nVisitor = NodeRunner()
    nVisitor.visit(node)
    print("-------------------")
    nVisitor = NodeChecker()
    nVisitor.visit(node)
    print("-------------------")
    print "node_a_a_a: result: %s" % node_a_a_a.result
    print "node_a_a_b: result: %s" % node_a_a_b.result
    print "node_a_a: result: %s" % node_a_a.result
    print "node_a_b_a: result: %s" % node_a_b_a.result
    print "node_a_b: result: %s" % node_a_b.result
    print "node_a: result: %s" % node_a.result
    print "node: result: %s" % node.result

输出如下：

-------------------
Node_A_A_A: result:True
Node_A_A_B: result:False
Node_A_A: result:True
Node_A_B_A: result:True
Node_A_B: result:True
Node_A: result:True
Node: result:True
-------------------
-------------------
node_a_a_a: result: True
node_a_a_b: result: False
node_a_a: result: False
node_a_b_a: result: True
node_a_b: result: True
node_a: result: False
node: result: False

【讨论】：