Your task is to define a function that understands basic mathematical expressions and solves them.
For example:

```python
calculate("1 + 1")        # => 2
calculate("18 + 4*6")     # => 42
calculate("245 - 826")    # => -581
calculate("09 + 000482")  # => 491
calculate("8 / 4 + 6")    # => 8
calculate("5 + 1 / 5")    # => 5.2
calculate("1+2+3")        # => 6
calculate("9 /3 + 12/ 6") # => 5
```
Notes:

- Input string will contain numbers (may be integers and floats) and arithmetic operations.
- Input string may contain spaces, and all space characters should be ignored.
- Operations that will be used: addition (+), subtraction (-), multiplication (*), and division (/)
- Operations must be done in the order of operations: First multiplication and division, then addition and subtraction.
- In this kata, input expression will not have negative numbers. (ex: "-4 + 5")
- If output is an integer, return as integer. Else return as float.
- If input string is empty, contains letters, has a wrong syntax, contains division by zero or is not a string, return False.

Difficulty: introductory

Starter code:

def calculate(input):
	

Solutions:
import re
def calculate(input):
    try:
        return eval(re.sub(r'(\d+)', lambda m: str(int(m.group(1))), input))
    except:
        return False

import re
def calculate(s):
    try:
        s = re.sub(r'(?<!\d)0+(0|[1-9]\d*)', lambda m: m.group(1), s)
        s = re.sub(r'\d+(?!\.)', lambda m: m.group() + '.0', s)
        return eval(s)
    except:
        return False

import math
def solve(s: list, mp=0):
    LHS = s.pop(0)
    while len(s) > 0:
        #
        op = s[0]
        #
        p = 1 if op in '+-' else 2
        if p < mp: break
        p += 1
        s.pop(0)  #drop the operator because it being used
        #
        RHS = solve(s, p)
        if   op == '+': LHS+=RHS
        elif op == '-': LHS-=RHS
        elif op == '*': LHS*=RHS
        elif RHS  != 0: LHS/=RHS
        else:           return math.nan
    return LHS

def calculate(s):
    try:
        s=s.replace(' ', '')
    except:
        return False
    #
    dim = len(s)
    #
    if dim == 0: return False
    #
    for c in s: 
        if not (c in '0123456789.+-*/'): return False
    for i in range(dim-1):
        if s[i] in '+-*/' and s[i+1] in '+-*/': return False
    #
    exp = []
    i=0
    for j,c in enumerate(s):
        if i==j:
            pass
        elif c in ['+','-','*','/']:
            try:
                exp.append(float(s[i:j]))
            except:
                return False
            exp.append(s[j])
            i=j+1
    try:
        exp.append(float(s[i:]))
    except:
        return False
    #
    v = solve(exp)
    #
    if math.isnan(v):             return False
    if float(v) == float(int(v)): return int(v)
    return v

from re import sub

def calculate(input):
    try:
        return eval(sub(r'([^\d])0+(\d)', r'\1\2', input))
    except:
        return False

import re

def calculate(s):
    try:    return eval(re.sub(r'\b0+(?=[1-9])', '', s))
    except: return False

import re

def calculate(input):
    try:
        for n in re.findall("\d+", input):
            input = input.replace(n, (n.lstrip("0") or "0"))
        return eval(input)
    except: return False

import functools as ft
import math

ops = ['*', '/', '+', '-']


def SanitizeExpression(expression):
    return expression.replace("+-", "-").replace("-+", "-").replace("--", "+")
    pass


def ExtendList(arr, value, op):
    arr.extend(value.split(op))
    return arr


def LastIndexOfAny(expression, operators, startIndex):
    arr = [expression[0:startIndex].rfind(x) for x in operators]
    arr.sort()
    return arr[-1]
    pass


def IndexOfAny(expression, operators, startIndex):
    arr = [x + startIndex for x in [expression[startIndex:].find(x) for x in operators] if x != -1]
    if len(arr) == 0:
        arr = [-1]
    arr.sort()
    return arr[0]
    pass


def FloatToString(value):
    return "%.30f" % value
    pass


def EvaluateSimpleExpression(expression):
    numberText = expression.split(ops[0])
    numberText = ft.reduce(lambda r, s: ExtendList(r, s, ops[2]), numberText, [])
    numberText = ft.reduce(lambda r, s: ExtendList(r, s, ops[3]), numberText, [])
    numberText = ft.reduce(lambda r, s: ExtendList(r, s, ops[1]), numberText, [])

    numbers = [float(x) for x in numberText if x != '']

    minusCount = expression.count('-')

    if expression.count('*') > 0:
        return numbers[0] * numbers[1] * math.pow(-1, minusCount)

    if expression.count('/') > 0:
        return numbers[0] / numbers[1] * math.pow(-1, minusCount)

    if expression.count('-') > 0:
        return numbers[0] - numbers[1]

    return numbers[0] + numbers[1]
    pass


def ResolveSimpleExpression(expression, operatorIndex):
    startIndex = LastIndexOfAny(expression, ops, operatorIndex - 1) + 1
    indexNext = IndexOfAny(expression, ops, operatorIndex + 2)

    if indexNext == -1:
        length = len(expression)
    else:
        length = indexNext

    length -= startIndex

    return expression[startIndex:startIndex + length]
    pass


def EvaluateSimpleInComplexExpression(expression, operatorIndex):
    simple = ResolveSimpleExpression(expression, operatorIndex)
    simpleAns = EvaluateSimpleExpression(simple)
    if math.fabs(simpleAns) < 1e-10:
        simpleAns = 0
        pass

    insertIndex = expression.find(simple)

    return expression[0:insertIndex] + FloatToString(simpleAns) + expression[insertIndex + len(simple):]
    pass


def SimplifyExpressionByOperatorsRec(expression, applyNegative, multiplier, operators):
    if expression[0] == '+':
        expression = expression[1:]

    if applyNegative and expression[0] == '-':
        multiplier *= -1
        expression = expression[1:].replace("+", "X").replace("-", "+").replace("X", "-")
        pass

    indexArr = [x for x in [expression.find(op) for op in operators] if x > 0]
    if len(indexArr) > 0:
        indexArr.sort()
        index = indexArr[0]

        expression = EvaluateSimpleInComplexExpression(expression, index)
        expression = SanitizeExpression(expression)

        return SimplifyExpressionByOperatorsRec(expression, applyNegative, multiplier, operators)
        pass

    try:
        return FloatToString(float(expression) * multiplier)
    except:
        return expression
    pass


def SimplifyExpressionByOperators(expression, applyNegative, operators):
    return SimplifyExpressionByOperatorsRec(expression, applyNegative, 1, operators)


def EvaluateComplexExpression(expression):
    result = SimplifyExpressionByOperators(expression, False, ['*', '/'])

    return SimplifyExpressionByOperators(result, True, ['+', '-'])
    pass


def EvaluateBracketExpression(expression):
    closeIndex = expression.find(')')
    if closeIndex >= 0:
        openIndex = expression[0:closeIndex].rfind('(')
        startIndex = openIndex + 1
        length = closeIndex - startIndex

        complexExp = expression[startIndex:closeIndex]
        resolved = EvaluateComplexExpression(complexExp)

        expression = expression[0:openIndex] + str(resolved) + expression[openIndex + length + 2:]
        expression = SanitizeExpression(expression)

        return EvaluateBracketExpression(expression)
        pass

    return EvaluateComplexExpression(expression)
    pass


def calculate(expression):    
    try:
        test = 'string' + expression
    except:
        return False
    
    expression = str(expression).replace(" ", "")        
    if expression == '':
        return 0
    
    expression = SanitizeExpression(expression)

    try:
        return float(EvaluateBracketExpression(expression))
    except:
        return False
    pass



from re import sub

def calculate(s):
    try: return eval(sub(r'\b0+(?=\d)', '', s))
    except: return 0

class Calculator(object):

    operators = {'+': lambda x,y: x+ y,
                 '-': lambda x, y: x - y,
                 '*': lambda x, y: x * y,
                 '/': lambda x, y: x / y }
    high_pre = ['*', '/']

    def __init__(self):
        self.operand = []
        self.operator = []

    def parse_string(self, string):
        index = 0
        while index < len(string):
            end = index + 1
            while end < len(string) and string[end] not in list(self.operators.keys()):
                end += 1
            try:
                self.operand.append(float(string[index:end]))
            except:
                return False
            if end < len(string):
                self.operator.append(string[end])
            index = end + 1
        return True

    def evaluate(self, string = ""):
        if string == "":
            string = "0"

        valid = self.parse_string(string)
        if not valid:
            return False

        while len(self.operand) != 1:
            operator_index = len(string)
            for op in self.high_pre:
                if op in self.operator:
                    operator_index = min(operator_index, self.operator.index(op))
            if operator_index == len(string):
                operator_index = 0
            x = self.operand[operator_index]
            y = self.operand[operator_index + 1]
            op = self.operator[operator_index]
            try:
                self.operand[operator_index] = self.operators[op](x, y)
            except:
                return False
            self.operand.pop(operator_index + 1)
            self.operator.pop(operator_index)

        return self.operand[0]
        

def calculate(input):
    if type(input) != str:
        return False
    return Calculator().evaluate(input)


digits = '0123456789'
ops = '+-/*'

def calc(expr):
    r = []
    i = 0
    t = len(expr)
    c = ''
    s = ''
    left = 0
    right = 0
    cur_idx = 0
    while i < t:
        c = expr[i]
        if c in digits:
            if not s:
                s = c
            elif s[-1] in digits:
                s += c
            else:
                r += [s]
                s = c
        elif c == ' ':
            pass
        elif c in ops:
            r += [s] if s != '' else []
            r += [c]
            s = ''
        elif c == '(':
            left = 1
            right = 0
            cur_idx = i
            while i < t and left != right:
                i += 1
                if expr[i] == '(':
                    left += 1
                elif expr[i] == ')':
                    right += 1
            r += [calc(expr[cur_idx+1:i])]
        i += 1
    r += [s] if s != '' else []
    r_new = []
    for item in r:
        try:
            r_new.append(float(item))
        except ValueError:
            r_new.append(item)
    r = list(r_new)
    r_new = []
    i = 0
    t = len(r)
    while i < t:
        if r[i] == '-':
            if type(r[i+1])==float:
                r_new.append(-r[i+1])
            elif r[i+1] == '-':
                sign = 1
                while r[i+1] == '-':
                    sign *= -1
                    i += 1
                r_new.append(sign * r[i])
                i -= 1
            else:
                r_new.append(r[i])
                r_new.append(r[i+1])
            i += 2
        else:
            r_new.append(r[i])
            i += 1
    r_new = [d for d in r_new if d != '']
    while '*' in r_new or '/' in r_new:
        t = len(r_new)
        mul_idx = r_new.index('*') if '*' in r_new else t
        div_idx = r_new.index('/') if '/' in r_new else t
        if mul_idx == 0 or div_idx == 0:
            raise Exception()
        cur_idx = min(mul_idx, div_idx)
        new_numb = r_new[cur_idx-1] * r_new[cur_idx+1] if cur_idx == mul_idx else r_new[cur_idx-1] / r_new[cur_idx+1]
        r_new = r_new[:cur_idx-1] + [new_numb] + r_new[cur_idx+2:]
    return sum([d for d in r_new if d != '+'])
    

def calculate(x):
    if x == '':
        return False
    try:
        return calc(x)
    except:
        return False