Q:

Simple calculator in Python

This is my first ever Python program. I thought I would make a calculator that performs 5 operations: add, subtract, divide, multiply, power. I am aware Python has its own power function, called "pow", but I have defined my own power function for practice.
I've taken the input as a single string, and then I've tried to separate the numbers from the operator in my for loop, using what little Python I currently know. Perhaps this is the section of my code that could be made cleaner, above all else?
Coming from Java, my first instinct was to use a switch statement to handle each operator case. I quickly realised Python doesn't have switch statements, but I discovered that dictionaries are apparently a good substitute. But maybe there is a better way of handling each operator case?
And obviously, I should have error handling, but let's just ignore that detail for now.
val = str(input("Calculate: "))

# get first number, second number, and operator, from string
foundOp = False # has the operator been found?
a, b = "", "" # first and second number
for char in val:
    # concatenate digits
    if char.isdigit():
        if foundOp:
            b = b + char
        else:
            a = a + char
    # skip spaces
    elif char == " ":
        continue
    # find operator
    elif not char.isdigit():
        foundOp = True
        op = char

# convert a and b into int
a, b = int(a), int(b)

# compute a ^ b
def power(a,b):
    original_a = a
    for i in range(1,b):
        a *= original_a
    return a

calc = {
    "+": a + b,
    "-": a - b,
    "*": a * b,
    "/": a / b,
    "^": power(a,b)
}

print(calc[op])

A:

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

