If you want to make a simple calculator you could try implementing Shunting-yard algorithm.

But if you want to go with regex approach I d still do it a little differently:

import re

#In python functions/methods usually are lowercase
#and words are seperated by _ while classes use CamelCasing
def eval_step_by_step(expression):
    """Evaluates math expression. Doesn t do any error checking.
        expression (string) - math expression"""

    print expression
    #For pretty formating.
    expr_len = len(expression)
    #While there s parentheses in the expression.
    while True:
        #re.match checks for a match only at the beginning of the string,
        #while re.search checks for a match anywhere in the string.

        #Matches all numbers, +, -, *, / and whitespace within parentheses
        #lazily (innermost first).
        contents = re.search("(([0-9|*|/|+|-|s]*?))", expression) 
        #If we didn t find anything, print result and break out of loop.
        if not contents:
            #string.format() is the Python 3 way of formating strings
            #(Also works in Python 2.6).

            #Print eval(expression) aligned right in a "field" with width
            #of expr_len characters.
            print "{0:{1}}".format(eval(expression), expr_len)
            break

        #group(0) [match] is everything matching our search,
        #group(1) [parentheses_text] is just epression withing parentheses.
        match, parentheses_text = contents.group(0), contents.group(1)
        expression = expression.replace(match, str(eval(parentheses_text)))
        #Aligns text to the right. Have to use ">" here
        #because expression is not a number.
        print "{0:>{1}}".format(expression, expr_len)

#For example try: (4+3+(32-1)*3)*3
problem = raw_input("Input math problem: ")

eval_step_by_step(problem)

It doesn t exactly work the same as your function, but you could easily implement modifications into your function to match mine. As you can see, I ve also added a lot of comments to explain some stuff.

Some problems:

contents = re.match("((.*))", problem)

When it s given the input (1+2)/(3+4), it s going to try to evaluate 1+2)/(3+4.

It also doesn t go all the way into nested parentheses, for this you would need to use recursion.

I think you should make another attempt at this before you "look at the answers".

I d probably replace occurrences of

re.match( "(", problem)

with

problem.startswith("(")

In

contents = re.match("((.*))", problem)
parenthsAnswer = contents.group(0)

you don t check to see whether contents matches or not so if you pass it the input "(1" you ll get an exception when you try to evaluate contents.group(0)

Don t every use eval in a real program!

You could use pyparsing to make a full parser, but I think it is the kind of thing everyone should try on their own as an exercise at least once!

Why don t you match only for the double and matching parentheses? The first match for a single ( is not really necessary because if the match for the doubles fail, this means there are no expression for you to evaluate.

import re

def eval_parentheses(problem):
    contents = re.match("((.*))", problem)
    if contents:
    ...
    else:
        print "Couldn t find parentheses!"

Also, the parentheses selection algorithm could be improved a bit for nested parens etc.