Калькулятор для строковых выражений

>>> '1+2'.partition('+')
('1', '+', '2')
>>> '115+2'.partition('+')
('115', '+', '2')

s = 'один плюс ноль'
 
ls = s.split(' ')
 
d1 = {
    'ноль': 0,
    'один': 1,
    #…
    'двенадцать': 12,
    #…
    'девятьнадцать': 19,
}
d_op = {
    'плюс': lambda x, y: x + y,
    #…
}
 
i = 0
try:
    e1 = d1[ls[i]]
except KeyError:
    raise NotImplementedError
i += 1
 
try:
    func = d_op[ls[i]]
except KeyError:
    raise ValueError('ожидался оператор, найдена ересь: "%s"' % ls[i])
i += 1
 
try:
    e2 = d1[ls[i]]
except KeyError:
    raise NotImplementedError
i += 1
 
if i != len(ls):
    raise ValueError('найдена ересь: "%s"' % ls[i:])
 
r = func(e1, e2)
print(r)

el1 = "двадцать один"
op = "плюс"
el3 = "один"

digit={"один":1,"два":2,"три":3,"четыре":4,"пять":5,"шесть":6,"семь":7,"восемь":8,"девять":9,\
    "одиннадцать":11,"двенадцать":12,"тринадцать":13,"четырнадцать":14,"пятнадцать":15,"шестнадцать":16,"семнадцать":17,"восемнадцать":18,"девятнадцать":19,\
    "десять":10,"двадцать":20,"тридцать":30,"сорок":40,"пятьдесят":50,"шестьдесят":60,"семьдесят":70,"восемьдесят":80,"девяносто":90,\
    'плюс':'+','минус':'-','умножить':'*', 'делить':'/', 'степени':'**'}
 
 
 
 
 
def calc(mat_example=str(input('input expamle: ')).split(' ')):
    
    ls=list(mat_example)
 
    del1=''.join(ls)
    
    
    try:
        delete=del1.find('на')
        if delete!=0:
            ls.remove('на')
    except:
        pass
 
    try:
        delete1=del1.find('в')
        if delete1!=0:
            ls.remove('в')
    except:
        pass
    
    count=len(ls)
    
 
    for i in range (0,count):
        ls[i]=digit.get(ls[i])
 
    
    
    if count==3:
        if ls[1]=='+':
            answer=ls[0]+ls[2]
        elif ls[1]=='-':
            answer=ls[0]-ls[2]
        elif ls[1]=='*':
            answer=ls[0]*ls[2]
        elif ls[1]=='/':
            answer=ls[0]/ls[2]
        elif ls[1]=='**':
            answer=ls[0]**ls[2]
            
    
    elif count==5:
        y1=ls[0]+ls[1]
        y2=ls[3]+ls[4]
        if ls[2]=='+':
            answer=y1+y2
        elif ls[2]=='-':
            answer=y1-y2
        elif ls[2]=='*':
            answer=y1*y2
        elif ls[2]=='/':
          answer=y1/y2
        elif ls[2]=='**':
            answer=y1**y2
          
    elif count==4:
        if ls[1]=='+' or ls[1]=='-' or ls[1]=='*':
            y2=ls[2]+ls[3]
            if ls[1]=='+':
                answer=ls[0]+y2
            elif ls[1]=='-':
                answer=ls[0]-y2
            elif ls[1]=='*':
                answer=ls[0]*y2
            elif ls[2]=='/':
                answer=ls[0]/y2
            elif ls[2]=='**':
                answer= ls[0]**y2
        elif ls[2]=='+' or ls[2]=='-' or ls[2]=='*':
            y1=ls[0]+ls[1]
            if ls[1]=='+':
                answer=y1+ls[3]
            elif ls[1]=='-':
                answer=y1-ls[3]
            elif ls[1]=='*':
                answer=ls[3]*y1
            elif ls[1]=='/':
                answer=y1/ls[3]
            elif ls[1]=='**':
                answer==y1**ls[3]
    
    
    
    
    return round(answer,3)
 
print(calc())

dig1 = {
    0: 'ноль',
    1: 'один',
    #…
    19: 'девятнадцать',
}
dig2 = {
    2: 'двадцать',
    3: 'тридцать',
    #…
}
 
def int2str(i):
    if i < 0:
        return '<0'
    if i < 20:
        return dig1[i]
    if i >= 100:
        return '>100'
    # двузначное число
    d2 = i // 10
    d1 = i % 10
    if d1 == 0:
        return dig2[d2]
    return dig2[d2] + ' ' + dig1[d1]
 
print(int2str(21))

>>> d = {0:'ноль', 1:'один'}
>>> d
{0: 'ноль', 1: 'один'}
>>> d2 = {v:k for k, v in d.items()}
>>> d2
{'один': 1, 'ноль': 0}

>>> d2 = {}
>>> for k, v in d.items():
...    d2[v] = k
... 
>>> d2
{'один': 1, 'ноль': 0}

def calculate(expression):
    plus = lambda x,y: x+y
    minus = lambda x,y: x-y
    multiply = lambda x,y: x*y
    dictOfStrings = {'девяносто': 90,'восемьдесят': 80,'семьдесят': 70, 'шестьдесят': 60, 'пятьдесят': 50,
                     'сорок': 40,'тридцать': 30, 'двадцать': 20, 'девятнадцать': 19, 'восемнадцать': 18,
                     'семнадцать': 17, 'шестнадцать': 16, 'пятнадцать': 15, 'четырнадцать': 14,'тринадцать': 13,
                     'двенадцать': 12, 'одиннадцать': 11, 'десять': 10, 'девять': 9, 'восемь': 8, 'семь': 7,
                     'шесть': 6, 'пять': 5, 'четыре': 4, 'три': 3, 'два': 2, 'один': 1, 'ноль': 0,
                     'плюс': plus, 'минус': minus, 'умножить': multiply}
    
    dictOfNums = {9000: 'девять тысяч', 8000: 'восемь тысяч', 7000: 'семь тысяч', 6000: 'шесть тысяч',
                  5000: 'пять тысяч', 4000: 'четыре тысячи', 3000: 'три тысячи', 2000: 'две тысячи',
                  1000: 'одна тысяча', 900:'девятьсот', 800:'восемьсот', 700:'семьсот', 600:'шестьсот',
                  9500:'пятьсот', 400:'четыреста', 300:'триста', 200:'двести', 100:'сто',
                  90:'девяноста', 80:'восемьдесят', 70:'семдесят', 60:'шестьдесят', 50:'пятьдесят',
                  40:'сорок', 30:'тридцать', 20:'двадцать', 19:'девятнадцать', 18:'восемнадцать',
                 17:'семнадцать', 16:'шестнадцать', 15:'пятнадцать', 14:'четырнадцать', 13:'тринадцать',
                 12:'двенадцать', 11:'одиннадцать', 10:'десять', 9:'девять', 8:'восемь', 7:'семь',
                 6:'шесть', 5:'пять', 4:'четыре', 3:'три', 2:'два', 1:'один', 0:''}
    expressionList = []
    operatorPosition = 0
    for i,item in enumerate(expression.split()):
        try:
            expressionList.append(dictOfStrings[item])
            if isinstance(dictOfStrings[item], type(lambda: None)):
                operatorPosition = i 
        except:
            return 'Ошибка ввода выражения'
    
    try:
        resultNum = expressionList[operatorPosition](sum(expressionList[:operatorPosition]),
                                           sum(expressionList[operatorPosition+1:]))
        resultList = []
        
        if resultNum < 0:
            resultList.append('минус')
            resultNum = abs(resultNum)
        elif resultNum == 0:
            return 'ноль'      
                
        for i in reversed(range(1,4)):
            j = resultNum//10**i*10**i
            if j == 0:
                continue
            elif (j < 20) & (i==1):
                resultList.append(dictOfNums[resultNum])
                break
            else:
                resultList.append(dictOfNums[j])
            resultNum -= j
        else:
            resultList.append(dictOfNums[resultNum])
        return ' '.join(resultList)
 
        
    except:
        return 'Ошибка ввода выражения'