本篇内容介绍了“python的简单四则运算语法树可视化如何实现”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

超过十年行业经验，技术领先，服务至上的经营模式，全靠网络和口碑获得客户，为自己降低成本，也就是为客户降低成本。到目前业务范围包括了：网站制作、做网站，成都网站推广，成都网站优化，整体网络托管，成都小程序开发，微信开发，APP应用开发，同时也可以让客户的网站和网络营销和我们一样获得订单和生意！

简单四则运算语法树可视化

如果想要动手尝试一下，需要安装一下这个 python 可视化库。

解析 AST

Python 的 ast 库有一个 parse 方法，可以把传入的内容，解析成一个 AST。然后我们使用 ast.dump 将其导出并打印。
注意：indent 这个参数是 Python 3.9 以后才有的，如果版本低的话，可以去掉，只会影响最后输出的格式。

好了，就是这么简单。我们已经做到了，因为这个库的功能很强大，但是这里只是用到一点点而已。其实这里已经可以看出基本的结构了，不过我的目的是生成这棵树的 JSON 表示。我想要使用上面的 Python 绘图库把它绘制出来，它所支持的输入是 JSON，并且它的格式为：

{
	"name": "A",
	"children": [
		"name": "B",
		"children": []
	]
}

粗糙的遍历方法

"""
Python's AST
利用 Python 的 ast 模块来解析表达式（简单的二元运算），
然后通过遍历语法树来生成 JSON 表示，再使用 PYthon 的库来
将其可视化。这个程序的目的是为了验证自己写的简易解析器是否正确。
"""

import ast
import json


# 操作类型和操作符映射的字典
OPERATORS = {
    ast.Add: "+",
    ast.Sub: "-",
    ast.Mult: "*",
    ast.Div: "/"
}


def generate(tree: ast.Module):
    """
    generate expression AST's representation of JSON
    """
    if not tree:
        raise Exception("Emtpy AST tree!")
    if tree.__class__ == ast.Module:
        print(json.dumps({
            "name": "Expr",
            "children": [DFS(tree.body[0].value)]  # type: ignore
        }, indent=4))


def DFS(node):
    """
    DFS AST
    """
    if not node:
        return {}

    if node.__class__ == ast.BinOp:
        return {
            "name": "BinOp",
            "children": [
                {
                    "name": "left",
                    "children": [
                        DFS(node.left)
                    ]
                },
                DFS(node.op),
                {
                    "name": "left",
                    "children": [
                        DFS(node.right)
                    ]
                }
            ]
        }

    if node.__class__ == ast.Constant:
        return {
            "name": "NUMBER",
            "children": [
                {
                    "name": str(node.value)  # Python 的绘图库，必须是字符串才能正常显示
                }
            ]
        }

    if node.__class__ in [ast.Add, ast.Sub, ast.Mult, ast.Div]:
        return {
            "name": "Op",
            "children": [
                {
                    "name": OPERATORS[node.__class__]
                }
            ]
        }

    # 这里我只处理 加减乘除和数字类型的运行
    raise Exception("There is not support extra type.")


if __name__ == "__main__":
    ast_tree = ast.parse("1+2+3+4+5")
    print(ast.dump(ast_tree, indent=4))
    generate(ast_tree)

运行结果：
我这里会输出两个东西，一个是 AST 的 dump；另一个是 AST 的 JSON 表示（逻辑结构的 JSON 表示，不是对象的 JSON 表示）。

渲染显示

把打印出来的 JSON 字符串复制进文件，命名为 data.json。我感觉直接输出到控制台蛮有意思的，我喜欢直接看到它的结果。
执行如下命令：pytm-cli -d TB -i data.json -o demo.html
在浏览器打开 demo.html 即可看到效果了。

主流的遍历方法

上面这种遍历方法虽然便于理解，但是难以扩展。AST 通常是通过 访问者模式进行遍历的，而且 ast 库也提供了几种遍历方法。
因为这里只需要遍历来生成 JSON，并不需要修改AST本身，所以我们只看下面这两种即可。显然第一种是不能用的，原因已经用蓝色标记出来了。它自己说了如果你不关心上下文，因为生成 JSON 实际上是需要关注这个的。所以，我选择下面的 ast.NodeVisitor。使用它也很简单，继承这个类，然后对不同的节点写不同的处理逻辑就行了（这样把不同节点的逻辑分开了，降低了代码的耦合性）。

完整代码

"""
Python's AST
利用 Python 的 ast 模块来解析表达式（简单的二元运算），
然后通过遍历语法树来生成 JSON 表示，再使用 PYthon 的库来
将其可视化。这个程序的目的是为了验证自己写的简易解析器是否正确。
"""

import ast
import json


# 操作类型和操作符映射的字典
OPERATORS = {
    ast.Add: "+",
    ast.Sub: "-",
    ast.Mult: "*",
    ast.Div: "/"
}

class JSONVisitor(ast.NodeVisitor):
    """
    JSON visitor: Traversal AST and generate JSON representation
    """

    def visit_Module(self, node):
        module = {
            "name": "Module",
            "children": []
        }
        for sub_node in node.body:
            module["children"].append(self.visit(sub_node))

        return module

    def visit_Expr(self, node):
        return {
            "name": "Expr",
            "children": [
                self.visit(node.value)
            ]
        }

    def visit_BinOp(self, node):
        return {
            "name": "BinOp",
            "children": [
                {
                    "name": "left",
                    "children": [
                        self.visit(node.left)
                    ]
                },
                self.visit(node.op),
                {
                    "name": "right",
                    "children": [
                        self.visit(node.right)
                    ]
                }
            ]
        }

    def visit_Constant(self, node):
        return {
            "name": "NUMBER",
            "children": [{
                "name": str(node.value)  # # Python 的绘图库，必须是字符串才能正常显示
            }]
        }

    def visit_Add(self, node):
        return self.__visit(node)

    def visit_Sub(self, node):
        return self.__visit(node)

    def visit_Mult(self, node):
        return self.__visit(node)

    def visit_Div(self, node):
        return self.__visit(node)

    def __visit(self, node):
        return {
            "name": "Op",
            "children": [{
                "name": OPERATORS[node.__class__]
            }]
        }


if __name__ == "__main__":
    ast_tree = ast.parse("1+2+3+4+5")
    visitor = JSONVisitor()
    json_str = visitor.visit(ast_tree)
    print(json.dumps(json_str, indent=4))

前面那个粗糙版本是直接从 Expr 开始的，这个优雅点的版本，我就把 Module 节点也添加进去了。

“python的简单四则运算语法树可视化如何实现”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！

分享题目：python的简单四则运算语法树可视化如何实现
文章链接：http://myzitong.com/article/gohcip.html