脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python实现访问者模式详情

Python实现访问者模式详情

2022-11-17 11:39Moelimoe Python

这篇文章主要介绍了Python实现访问者模式详情，访问者模式，指作用于一个对象结构体上的元素的操作。访问者可以使用户在不改变该结构体中的类的基础上定义一个新的操作，下文更多相关资料,需要的朋友可以参考下

假设要实现一个存放多种类型数据结构的对象，比如一个存放算术操作数和操作符的树结点，需要存放包含一元操作符、二元操作符和数字类型的结点

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Node:
    pass
 
 
class UnaryOperator(Node):
    def __init__(self, operand):
        self.operand = operand
 
 
class BinaryOperator(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right
 
 
class Add(BinaryOperator):
    pass
 
 
class Sub(BinaryOperator):
    pass
 
 
class Mul(BinaryOperator):
    pass
 
 
class Div(BinaryOperator):
    pass
 
 
class Negative(UnaryOperator):
    pass
 
 
class Number(Node):
    def __init__(self, value):
        self.value = value

执行运算需要这样调用：

?
1
2
3
4
5
# 假设运算式子：2 - (2+2) * 2 / 1 = 2-(8) = -6.0
t1 = Add(Number(2), Number(2))
t2 = Mul(t1, Number(2))
t3 = Div(t2, Number(1))
t4 = Sub(Number(2), t3)

或者这样调用：

?
1
t5 = Sub(Number(2), Div(Mul(Add(Number(2), Number(2)), Number(2)), Number(1)))

这样子需要执行多次类的调用，极不易读写且冗长，有没有一种方法让调用更加通用，访问变得简单呢。这里使用访问者模式可以达到这样的目的。

访问者模式能够在不改变元素所属对象结构的情况下操作元素，让调用或调用者（caller）的方式变得简单，这种操作常见于的士公司操作，当一个乘客叫了一辆的士时，的士公司接收到了一个访问者，并分配一辆的士去接这个乘客。

首先定义一个访问者结点类VisitorNode，实现最基本的访问入口，任何访问的方式都需要继承这个访问者结点类，并通过这个访问者结点类的visit()方法来访问它的各种操作

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 访问者节点的基类
class NodeVisitor:
    def visit(self, node):
        if not isinstance(node, Node):  # 不是Node对象时当做一个值返回，如果有其他情况可以根据实际来处理
            return node
        self.meth = "visit_" + type(node).__name__.lower()  # type(node)也可以换成node.__class__（只要node.__class__不被篡改）
        meth = getattr(self, self.meth, None)  
        if meth is None:
            meth = self.generic_visit
        return meth(node)
 
    def generic_visit(self, node):
        raise RuntimeError(f"No {self.meth} method")
 
 
# （一种）访问者对应的类
class Visitor(NodeVisitor):
    """
    方法的名称定义都要与前面定义过的结点类（Node）的名称保证一致性
    """
 
    def visit_add(self, node):
        return self.visit(node.left) + self.visit(node.right)
 
    def visit_sub(self, node):
        return self.visit(node.left) - self.visit(node.right)
 
    def visit_mul(self, node):
        return self.visit(node.left) * self.visit(node.right)
 
    def visit_div(self, node):
        return self.visit(node.left) / self.visit(node.right)
 
    def visit_negative(self, node):  # 如果class Negative 命名-> class Neg，那么 def visit_negative 命名-> def visit_neg
        return -self.visit(node.operand)
 
    def visit_number(self, node):
        return node.value

这里的meth = getattr(self, self.meth, None)使用了字符串调用对象方法，self.meth动态地根据各类Node类（Add, Sub, Mul…）的名称定义了对应于类Visitor中的方法（visit_add, visit_sub, visit_mul…）简化了访问入口的代码，当没有获取到对应的方法时会执行generic_visit()并抛出RuntimeError的异常提示访问过程中的异常

如果需要添加一种操作，比如取绝对值，只需要定义一个类class Abs(Unaryoperator): pass并在类Visitor中定义一个visit_abs(self, node)方法即可，不需要做出任何多余的修改，更不需要改变存储的结构

这里visit()方法调用了visit_xxx()方法，而visit_xxx()可能也调用了visit()，本质上是visit()的循环递归调用，当数据量变大时，效率会变得很慢，且递归层次过深时会导致超过限制而失败，而下面介绍的就是利用栈和生成器来消除递归提升效率的实现访问者模式的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
import types
 
 
class Node:
    pass
 
 
class BinaryOperator(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right
 
 
class UnaryOperator(Node):
    def __init__(self, operand):
        self.operand = operand
 
 
class Add(BinaryOperator):
    pass
 
 
class Sub(BinaryOperator):
    pass
 
 
class Mul(BinaryOperator):
    pass
 
 
class Div(BinaryOperator):
    pass
 
 
class Negative(UnaryOperator):
    pass
 
 
class Number(Node):
    def __init__(self, value):  # 与UnaryOperator区别仅命名不同
        self.value = value
 
 
class NodeVisitor:
    def visit(self, node):
        # 使用栈+生成器来替换原来visit()的递归写法
        stack = [node]
        last_result = None  # 执行一个操作最终都会返回一个值
        while stack:
            last = stack[-1]
            try:
                if isinstance(last, Node):
                    stack.append(self._visit(stack.pop()))
                elif isinstance(last, types.GeneratorType):   # GeneratorType会是上一个if返回的对象，这个对象会返回两个node执行算术之后的结果
                    # 如果是生成器，不pop掉，而是不断send，直到StopIteration
                    # 如果last_result不是None，这个值会给回到生成器（例如2被visit_add()的左值接收到）
                    stack.append(last.send(last_result))
                    last_result = None
                else:   # 计算结果是一个值
                    last_result = stack.pop()
            except StopIteration:   # 生成器yield结束
                stack.pop()
        return last_result
 
    def _visit(self, node):
        self.method_name = "visit_" + type(node).__name__.lower()
        method = getattr(self, self.method_name, None)
        if method is None:
            self.generic_visit(node)
        return method(node)
 
    def generic_visit(self, node):
        raise RuntimeError(f"No {self.method_name} method")
 
 
class Visitor(NodeVisitor):
    def visit_add(self, node):
        yield (yield node.left) + (yield node.right)    # node.left和node.right都可能是Node
 
    def visit_sub(self, node):
        yield (yield node.left) - (yield node.right)
 
    def visit_mul(self, node):
        yield (yield node.left) * (yield node.right)
 
    def visit_div(self, node):
        yield (yield node.left) / (yield node.right)
 
    def visit_negative(self, node):
        yield -(yield node.operand)
 
    def visit_number(self, node):
        return node.value

测试是否还会引起超过递归层数的异常

?
1
2
3
4
5
6
7
8
9
def test_time_cost():
    import time
    s = time.perf_counter()
    a = Number(0)
    for n in range(1, 100000):
        a = Add(a, Number(n))
    v = Visitor()
    print(v.visit(a))
    print(f"time cost:{time.perf_counter() - s}")

输出正常，没有问题

4999950000
time cost:0.9547078

最后琢磨出了一个似乎可以作为替代的方法：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
clas Node:
    psass
 
 
class UnaryOperator(Node):
    def __init__(self, operand):
        self.operand = operand
 
 
class BinaryOperator(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right
 
 
class Add(BinaryOperator):
    def __init__(self, left, right):
        super().__init__(left, right)
        self.value = self.left.value + self.right.value
    pass
 
 
class Sub(BinaryOperator):
    def __init__(self, left, right):
        super().__init__(left, right)
        self.value = self.left.value - self.right.value
    pass
 
 
class Mul(BinaryOperator):
    def __init__(self, left, right):
        super().__init__(left, right)
        self.value = self.left.value * self.right.value
    pass
 
 
class Div(BinaryOperator):
    def __init__(self, left, right):
        super().__init__(left, right)
        self.value = self.left.value / self.right.value
    pass
 
 
class Negative(UnaryOperator):
    def __init__(self, operand):
        super().__init__(operand)
        self.value = -self.operand.value
    pass
 
 
class Number(Node):
    def __init__(self, value):
        self.value = value

运行测试：

?
1
2
3
4
5
6
7
8
def test_time_cost():
    import time
    s = time.perf_counter()
    a = Number(0)
    for n in range(1, 100000):
        a = Add(a, Number(n))
    print(a.value)
    print(time.perf_counter() - s)

输出：

4999950000
0.2506986

到此这篇关于Python实现访问者模式详情的文章就介绍到这了,更多相关Python访问者模式内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/Moelimoe/article/details/123755397

  • Python
  • 访问者模式

    • 延伸 · 阅读

    精彩推荐
    • Python七种Python代码审查工具推荐

      七种Python代码审查工具推荐

      这篇文章主要介绍了七种Python代码审查工具推荐，帮助大家更好的理解和学习使用python，感兴趣的朋友可以了解下...

      51CTO11732021-09-18
    • PythonPython元字符的用法实例解析

      Python元字符的用法实例解析

      这篇文章主要介绍了Python元字符的用法实例解析，具有一定借鉴价值,需要的朋友可以参考下...

      powerpoint_201610132021-01-05
    • Pythonpython编写softmax函数、交叉熵函数实例

      python编写softmax函数、交叉熵函数实例

      这篇文章主要介绍了python编写softmax函数、交叉熵函数实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      ChunxueShi3762020-06-12
    • Pythonpython在线编译器的简单原理及简单实现代码

      python在线编译器的简单原理及简单实现代码

      这篇文章主要介绍了python在线编译器的简单原理及简单实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧...

      superboycxx9672021-01-11
    • PythonPython中使用PIPE操作Linux管道

      Python中使用PIPE操作Linux管道

      这篇文章主要介绍了Python中使用PIPE操作Linux管道,本文先是讲解了一些管道的知识,然后给出示例代码,需要的朋友可以参考下 ...

      脚本之家7422020-05-22
    • Pythonpython3用PIL把图片转换为RGB图片的实例

      python3用PIL把图片转换为RGB图片的实例

      今天小编就为大家分享一篇python3用PIL把图片转换为RGB图片的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      农民小飞侠11022021-07-31
    • Pythonpython命令行参数用法实例分析

      python命令行参数用法实例分析

      这篇文章主要介绍了python命令行参数用法,结合实例形式分析了Python基于optparse模块处理命令行参数相关使用技巧,需要的朋友可以参考下...

      轻舞肥羊9852021-07-20
    • Python你会使用python爬虫抓取弹幕吗

      你会使用python爬虫抓取弹幕吗

      这篇文章主要为大家详细介绍了python爬虫抓取弹幕的方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      璨星烁5772022-09-13
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 星空大战 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图