Simple calculator in Python
Use functions

It's generally a good idea to sort your functionality into functions. Allows you for nice reuse and stuff like that.

string.split()

So how will we parse? Of course, you can parse every single input like you do, or even upgrade it to a tokenizer engine if you got a lot of spare time and effort. There's really 2 ways to go about there here. The simple one is string.split(). The complicated one is regexes, but you probably won't need these unless you're planning big. 

Map to functions, not precomputed results

You'll notice I import functions from the operator builtin module. These do the exact same thing as the +, -, /, * and **(power) symbols, but we can use them as functions. This lets us put them in a dict we can create before we ask for user input. It also means we don't have to calculate all the operations, and can stick to only calculating the one we actually are interested in. Do note that this also obsoletes your power function, much as you could have done using ** yourself.

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

def calculate():
    operators = {
        "+": add,
        "-": sub,
        "/": truediv,  # floordiv also exists, which is integer division
        "*": mul,
        "^": pow
    }
    val = input("Calculate: ")  # Do note that it's already a string, so you don't need to cast to one.
    for symbol, operator in operators.items():
        if symbol in val:  # Check if the symbol is in the string
            a, b = val.split(symbol)
            return operator(float(a), float(b))  # Cast them to floats - all builtin operators can handle them.

if __name__ == "__main__":
    print(calculate())


Last thing I added was what we call a guard. It makes you able to import this function from another script and use it, without having to run it.

If you want to go for bonus points, you can also switch to regexes for your input parsing.

Bonus info: Iterators

Python does a lot of smart things with iterators. For example, we're iterating over a dictionary here. A dictionary looks like this:

my_dict = {
    "key1": "value1",
    "key2": "value2",
    # etc...
}


It's a hashtable for the keys, and under the hood these are linked to pointers to the values. We can iterate over a dictionary in three ways: Over the keys, over the values, and over key: value pairs. 

Keys

for key in my_dict:
    # "key1", "key2"....
# OR:
for key in my_dict.keys():
    # "key1", "key2"....


Values

for value in my_dict.values():
    # "value1", "value2"....


key/value pairs

for key, value in my_dict.items():
    # ("key1", "value1"), ("key2", "value2")....


In case of items(), the iterator gives a tuple of length 2 for every iteration. By assigning that tuple to key, value, we unpack it. This works the same as in the line:

a, b = 1, 2


On the RHS, we construct a 2-length tuple (1, 2), which is passed to the LHS, where it is unpacked to a, b. Since tuples enforce ordering, that's how python decides which value to put where.

See also: Python Docs Dictionary Looping Techniques