在Python中编写一个计算数学表达式的程序，不使用内置函数

在Python中，计算数学表达式是一个很常见的需求。虽然内置函数提供了一些基本的数学计算方法，但对于更加复杂的数学表达式，我们可能需要自己编写程序来实现。

本文将介绍如何在Python中编写一个计算数学表达式的程序，同时不使用内置函数。

更多Python相关文章，请阅读：Python 教程

安装依赖库

在编写程序之前，我们需要安装一个依赖库——lark-parser。这个库提供了解析数学表达式的功能，可以将一个字符串形式的数学表达式转化为一个抽象语法树（AST），从而方便我们进行计算。

我们可以使用pip命令来安装这个库：

pip install lark-parser

解析数学表达式

要解析字符串形式的数学表达式，我们可以先使用lark-parser库提供的语法来定义一个文法。然后，使用该库提供的Lark类来将字符串转化为抽象语法树。

下面是一个简单的文法定义，用于解析加、减、乘、除运算表达式：

// 定义一个文法
start: sum
sum: product | sum "+" product | sum "-" product
product: factor | product "*" factor | product "/" factor
factor: NUMBER | "(" sum ")" | "-" factor | "+" factor
%import common.NUMBER
%import common.WS
%ignore WS

该文法定义了四个运算表达式：加、减、乘和除。其中，sum规则表示加、减运算，product规则表示乘、除运算，factor规则表示数字、括号、正负号。

接下来，我们可以使用下面的代码将一个字符串解析为一个抽象语法树：

from lark import Lark

# 定义文法
grammar = """
start: sum
sum: product | sum "+" product | sum "-" product
product: factor | product "*" factor | product "/" factor
factor: NUMBER | "(" sum ")" | "-" factor | "+" factor
%import common.NUMBER
%import common.WS
%ignore WS
"""
# 创建解析器
parser = Lark(grammar, parser='lalr', transformer=TreeTransformer())

# 解析表达式
tree = parser.parse("3 + 4 * (2 - 1)")

# 打印抽象语法树
print(tree.pretty())

通过上面的代码，我们可以将一个字符串"3 + 4 * (2 - 1)"解析为一个抽象语法树。接下来，我们需要将这个抽象语法树转化为计算结果。

计算抽象语法树

现在，我们已经得到了一个抽象语法树，可以通过遍历该树来计算数学表达式的值。

首先，我们需要编写一个辅助函数eval_node，用于计算某个抽象语法树节点的值。这个函数的参数是一个抽象语法树节点，返回值是一个数字。

def eval_node(node):
    if node.data == 'sum':
        if len(node.children) == 1:
            return eval_node(node.children[0])
        elif node.children[1].value == '+':
            return eval_node(node.children[0]) + eval_node(node.children[2])
        elif node.children[1].value == '-':
            return eval_node(node.children[0]) - eval_node(node.children[2])
    elif node.data == 'product':
        if len(node.children) == 1:
            return eval_node(node.children[0])
        elif node.children[1].value == '*':
            return eval_node(node.children[0]) * eval_node(node.children[2])
        elif node.children[1].value == '/':
            return eval_node(node.children[0]) / eval_node(node.children[2])
    elif node.data == 'factor':
        if len(node.children) == 1:
            return float(node.children[0].value)
        elif node.children[0].value == '-':
            return -eval_node(node.children[1])
        elif node.children[0].value == '+':
            return eval_node(node.children[1])
        else:
            return eval_node(node.children[1])

接下来，我们可以通过遍历抽象语法树来计算表达式的值。具体来说，我们可以编写一个递归函数eval_tree，该函数的参数是一个抽象语法树节点，返回值是一个数字。

def eval_tree(node):
    if node.data in ['sum', 'product']:
        return eval_node(node)
    elif node.data == 'factor':
        return eval_node(node)

    nodes = node.children
    left = nodes.pop(0)
    result = eval_tree(left)

    for i, right in enumerate(nodes):
        if right.data == 'NUMBER' or right.data == 'factor':
            right_value = eval_node(right)
        else:
            right_value = eval_tree(right)
        if nodes[i - 1].value == '+':
            result += right_value
        elif nodes[i - 1].value == '-':
            result -= right_value

    return result

现在，我们已经可以计算任意一个数学表达式了。下面是一个完整的例子：

from lark import Lark, Transformer

# 定义文法
grammar = """
start: sum
sum: product | sum "+" product | sum "-" product
product: factor | product "*" factor | product "/" factor
factor: NUMBER | "(" sum ")" | "-" factor | "+" factor
%import common.NUMBER
%import common.WS
%ignore WS
"""

class TreeTransformer(Transformer):
    def sum(self, values):
        return values

    def product(self, values):
        return values

    def factor(self, values):
        return values

# 创建解析器
parser = Lark(grammar, parser='lalr', transformer=TreeTransformer())

# 计算表达式的值
expr = "3 + 4 * (2 - 1)"
tree = parser.parse(expr)
result = eval_tree(tree)

print(f"{expr} = {result}")