Simple python calculator

1

Despite the fact that bare except works, it would be nicer to be more explicit about what exception you are catching. I would write

except ValueError:

2

pow shadows away the function provided by Python; I would rename it to, say, mypow. Not that it matters in this case, but in a larger program you should not do this: finding bugs due to a shadowed identifier is hard.

3

You can rewrite the actual logic much more succintly by using a dictionary mapping the name of an operator to the actual function performing the operation.

Summa summarum

All in all, I had this in mind:

    def add(a, b):
        return a + b


    def sub(a, b):
        return a - b


    def mul(a, b):
        return a * b


    def div(a, b):
        return a / b


    def mypow(a, b):
        return a ** b


    if __name__ == "__main__":
        operator_map = {"+": add, "-": sub, "*": mul, "/": div, "pow": mypow}

        while True:
            try:
                number1 = float(input("Enter the first number: "))
                number2 = float(input("Enter the second number: "))
            except ValueError:
                print("That is not a number!")
                continue

            operator = input("Enter an operator (valid operators are +, -, *, / and pow): ")
            print(operator_map[operator](number1, number2) if operator in operator_map else "Invalid operator!")

Hope that helps.

Don't ever use input in a function that does work. It violates "separation of concerns" by tying the abstract calculation logic to the means by which the input is obtained.

Far better would be:

def binary_operation(operation, left, right):
    """Returns the result of applying operation to its arguments."""
    return operator_map[operation](left, right)

where operator_map is taken from @coderodde's answer. This allows you to call your (simple) engine in ways that have no connection to how the operands get there. For example:

binary_operation('+', 2, 3)
binary_operation(sys.argv[1], float(sys.argv[2]), float(sys.argv[3]))

you can also have the original behavior with

binary_operation(input('operator'), float(input('number')), float(input('number'))

or even

binary_operation('*', 5.0 binary_operation('+' 2, 3))

Prior to posting, I find that Joe Wallis suggested this, but I think it important enough to elaborate on its own.

You don't need to define all of those functions because the operator module already did, and they happen to have the same names as yours.

You use __name__. That's great. Since you won't be defining functions anymore (because of ^^), this file will be completely useless as a module. Therefore, I probably wouldn't bother with it. I might define a function to get input and then have a while True:

def get_answer(num1, num2, op):
    ...
if __name__ == '__main__':
    while True:
        try:
            number1 = float(input(...))
            number2 = float(input(...))
        except ValueError:
            print("That is not a number!")
            continue
        operator = input(...)
        answer = get_answer(number1, number2, operator)
        if answer is None:
            print("Invalid operator!")
        else:
            print(answer)

That's just a rough draft. I probably wouldn't do that, but it is a possibility.

Never have a bare except unless you are writing your own interpreter. You should have expectations for what errors you might get. Let's say you mis-spelled number1 and said numberl. There would be an error, so it would say That is not a number! ... no matter what you type. What is your expectation? Of course, it's that the user might type an invalid float. In that case, use except ValueError:

I would use a dictionary for the different operations, and I would use the more standard operator names. That is, ^ instead of pow. I would also tell the user the options at the beginning instead of telling him each time. Here is the full program:

import operator

operators = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv,
    '%': operator.mod,
    '^': operator.pow,
    '//': operator.floordiv,
    '>': operator.gt,
    '<': operator.lt,
    '=': operator.eq,
    '!=': operator.ne,
    '>=': operator.ge,
    '<=': operator.le,
}

def get_answer(num1, num2, op):
    try:
        return operators[op](num1, num2)
    except IndexError:
        raise ValueError("Invalid operator")

if __name__ == '__main__':
    operator_string = ', '.join(operators)
    print("Valid operators: {}\n".format(operator_string))
    while True:
        try:
            number1 = float(input("Enter the first number: "))
            number2 = float(input("Enter the second number: "))
        except ValueError:
            print("That is not a number!")
            continue
        except (KeyboardInterrupt, EOFError):
            break # exit
        op = input("Enter an operator: ")
        try:
            print(get_answer(number1, number2, op))
        except ValueError:
            print("Invalid operator!")