Turn a string into an operation

Question

Is there any way to convert a string with variables into an operation??

For example

a = 3
b = 7

str = 'a * b'

# *MAGIC SOLUTION TO TURN IT INTO AN OPERATION*

print (str) # Prints 21

Please, don't give others solutions for the problem, because I know it's very easy to do by a diferent way. But I really need it for a harder problem

Answer 1

You can do this safely by using in-built operator package, and using globals

from operator import sub, add, truediv, mul
import re

def string_eval(str_):
     operators = {'-': sub, '+': add, '/': truediv, '*': mul}
     pattern = re.compile(r'(.*?)\s*([*\/+-])\s*(.*)')  
     splited = re.search(pattern, str_).groups()
     if len(splited) == 3:
         a, ope, b = splited
         val_a = globals()[a]
         val_b = globals()[b]
         return operators[ope](val_a, val_b)

Now for this to work you have to declare the variables first

>>> a = 45
>>> b = 25
>>> string_eval('a - b')
20
>>> string_eval('a * b')
1125

Answer 2

In Python 3.6+, you can use literal string interpolation.

a = 3
b = 7

print(f'{a * b}') # prints: '21'

Answer 3

I'm assuming "don't give others solutions for the problem, because I know it's very easy to do by a diferent way" is referring to eval as the easy answer you don't want.

But really, what you want is almost certainly a function that parses and interprets an expression in some language, just like eval does, it's just that you want a simpler and more restricted language than Python, maybe just basic arithmetic expressions.

As Olivier Melançon's answer shows, Python also comes with an interpreter for a limited subset of Python in the f-string evaluator, and as jedwards' answer shows, there are readily-available interpreters for what are effectively similar languages to such a subset.

---

But if you want to handle exactly the language you want in exactly the way you want, you have to do it yourself. And it's not actually as scary as it sounds. I'll use Python's own ast module for parsing, but then write my own interpreter. This works as long as you really want a strict subset of Python, but if you want something different—e.g., ^ for exponentiation (which has the wrong precedence and associativity), or variables that aren't valid Python identifiers, etc., you'll have to build the parser too.

import ast
import operator

ops = {
    ast.Add: operator.add, 
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
}
def interpret(expr, env):
    if isinstance(expr, ast.Expr):
        return interpret(expr.value, env)
    elif isinstance(expr, ast.BinOp):
        op = ops[type(expr.op)]
        return op(interpret(expr.left, env), interpret(expr.right, env))
    elif isinstance(expr, ast.Num):
        return expr.n
    elif isinstance(expr, ast.Name):
        val = env[expr.id]
        if isinstance(val, (bool, int, float, complex)):
            return val
        raise ValueError(val)
    else:
        raise ValueError(expr)
def evaluate(s, env=None):
    if env is None: env = globals()
    tree = ast.parse(s)
    return interpret(tree.body[0], env)

Now, you can evaluate anything using the basic 4 arithmetic operators, parentheses, numeric constants, or the names of global variables whose values are numbers, but nothing else:

>>> a = 3
>>> b = 7
>>> evaluate('a * b')
21
>>> evaluate('3*a + 2*(b+10)')
32
>>> evaluate('__import__("os")')
ValueError: <_ast.Call object at 0x109210da0>
>>> evaluate('a * b', {'a': 10, 'b': 1j})
10j
>>> evaluate('-2')
ValueError: <_ast.UnaryOp object at 0x1092fc5c0>

Obviously the error handling could be nicer, and I probably should have handled at least unary - in case you want negative numbers… but this should be enough to get the point across. And reading the ast docs linked above, it should be clear how to extend this further.

---

On the other hand, Bijoy's answer is an even simpler parser and interpreter. It won't handle more complicated expressions—but if you don't want it to, that's a feature, not a bug.

Answer 4

Using the sympy library (docs) is one approach:

from sympy import Symbol, sympify

# Define symbols
a = Symbol('a')
b = Symbol('b')

# Parse the string into an equation
eqn = sympify('a * b')

# Substitute values for variables
eqn = eqn.subs(a, 3)
eqn = eqn.subs(b, 7)

print(eqn) # Prints 21

Or, even closer to what you had written (but I like it considerably less):

from sympy import sympify

a = 3
b = 7

# Parse the string into an equation
eqn = sympify('a * b', locals = locals())

print(eqn) # Prints 21

EDIT NOTE: Obligatory mention of disappointment, sympify, the string-to-equation parsing command, using eval(). :sad face:

That being said, sympy is a helpful library worth considering, and you can certainly build an equation without using sympify.