Invoking built-in operators indirectly in Python

Question

Let's say you have a small calculator program that takes numbers and an operator to perform on those numbers as input, then prints out the result of applying the specified operation. So if you input "4 + 5" it will print out "9". Simple, right? Well what I want to be able to write is something this:

a, op, b = raw_input().split()
print somehowInvokeOperator(op, a, b)

The problem is that "somehowInvokeOperator()" part. Is there anyway to do this without resorting to either (a) eval() or (b) some type of dictionary mapping keys like "+" and "-" to functions that perform the appropriate operation? getattr() doesn't appear to work for this. I don't really need this code for anything, I'm just curious to see if this can be solved in Python as elegantly as it can in other dynamic languages.

Answer 1

If you really wanted to do this, you would need the standard operator module. See also Emulating numeric types. And, yes, a dictionary full of functions would be a perfectly sound dynamic way to make this happen.

import operator
operations = {'+' : operator.add}
result = operations[op](a, b)

Answer 2

Basically no, you will at least need to have a dictionary or function to map operator characters to their implementations. It's actually a little more complicated than that, since not all operators take the form a [op] b, so in general you'd need to do a bit of parsing; see http://www.python.org/doc/2.6/library/operator.html for the full list of correspondences, and for the functions you'll probably want to use for the operator implementations.

If you're only trying to implement the binary arithmetic operators like + - * / % ** then a dictionary should be good enough.

Answer 3

Warning: this is not pythonic at all!! (goes against every rule of the Zen of Python!)

Here's a magical, one-liner dictionary:

ops = eval( '{%s}'%','.join([('\''+op + '\' : lambda a,b: a ' + op + ' b') for op in '+-*/%']) )

That defines your dictionary .. which you can use

ops['+'](10,4) #returns 14

the basic idea is mapping each operator to a lambda function:

{ '+' : lambda a,b: a + b }