How to Parse and Evaluate Mathematical Expressions in Python

etd_admin,

Parsing and evaluating mathematical expressions is a common task in programming, especially when building tools like calculators or interpreters. Python provides multiple ways to achieve this effectively. In this article, we’ll explore how to parse and evaluate mathematical expressions in Python using straightforward examples and practical explanations.

1. Using Python’s eval() Function

The simplest way to evaluate a mathematical expression in Python is with the built-in eval() function.

expression = "2 + 3 * 4 - (5 / 2)"
result = eval(expression)
print(f"Result: {result}")

The eval() function parses and evaluates the expression directly.

It supports Python’s operator precedence (e.g., multiplication is performed before addition).

eval() can execute arbitrary Python code, which may pose a security risk if the input is untrusted. For safer alternatives, consider the methods below.

2. Using the ast Module for Safer Evaluation

Python’s ast module can parse expressions into an Abstract Syntax Tree (AST), allowing you to evaluate mathematical expressions securely.

import ast
import operator

# Define allowed operators
def safe_eval(expr):
    allowed_operators = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.Pow: operator.pow,
        ast.USub: operator.neg,
    }

    def eval_node(node):
        if isinstance(node, ast.BinOp):
            left = eval_node(node.left)
            right = eval_node(node.right)
            return allowed_operators[type(node.op)](left, right)
        elif isinstance(node, ast.UnaryOp):
            operand = eval_node(node.operand)
            return allowed_operators[type(node.op)](operand)
        elif isinstance(node, ast.Num):
            return node.n
        else:
            raise TypeError("Unsupported expression")

    parsed = ast.parse(expr, mode='eval')
    return eval_node(parsed.body)

# Example usage
expression = "2 + 3 * (4 - 1)"
result = safe_eval(expression)
print(f"Result: {result}")

The ast.parse() method parses the expression into a tree structure.

A recursive function evaluates each node in the tree, ensuring only allowed operators are executed.

This is more secure than eval() because you explicitly control which operations are permitted.

3. Using Third-Party Libraries (e.g., sympy)

For complex mathematical expressions, libraries like sympy offer powerful tools to parse and evaluate expressions.

from sympy import sympify

expression = "2 + 3 * (4 - 1)**2"
result = sympify(expression)
print(f"Result: {result}")

The sympify() function parses the expression into a symbolic form and evaluates it.

This supports advanced mathematical operations like calculus and symbolic algebra.

This handles complex expressions effortlessly and provides symbolic computation capabilities.

A Sample Calculator Program

import ast
import operator

def calculate(expression):
    allowed_operators = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.Pow: operator.pow,
        ast.USub: operator.neg,
    }

    def eval_node(node):
        if isinstance(node, ast.BinOp):
            left = eval_node(node.left)
            right = eval_node(node.right)
            return allowed_operators[type(node.op)](left, right)
        elif isinstance(node, ast.UnaryOp):
            operand = eval_node(node.operand)
            return allowed_operators[type(node.op)](operand)
        elif isinstance(node, ast.Num):
            return node.n
        else:
            raise TypeError("Unsupported expression")

    try:
        parsed = ast.parse(expression, mode='eval')
        return eval_node(parsed.body)
    except Exception as e:
        return f"Error: {e}"

# Example usage
while True:
    user_input = input("Enter a mathematical expression (or 'quit' to exit): ")
    if user_input.lower() == 'quit':
        break
    print(f"Result: {calculate(user_input)}")

Each method mentioned above offers unique advantages depending on your requirements, ranging from simplicity to security and advanced functionality. Start with the approach that best suits your application, and remember to prioritize safety when handling user-provided inputs.

Python