Калькулятор дробей и комбинаторики

def f_znak(s):  # ищем знак и его индекс в массиве
    global znak
    for i in range(len(s) - 1):
        if s[i] in znak:
            return i, s[i]

def pretty_num(): #красиво разибаев число и делаем в s два элемента 1 содердит первое число, 2 второе в текстовом виде
    global s, znak_n, znak_z
    if not 'по' in s:
        znak_n, znak_z = f_znak(s)
        s[znak_n] = '*'
        s = ' '.join(s).split('*')
        s = [s[i].split() for i in range(len(s))]
    return s
def enum(i):  # ищем числитель и знаменатель дроби
    if ' и ' in i:
        numerator, denumerator = enum(i[2:])
        numerator += denumerator * i[0]
        return numerator, denumerator
    numerator, denumerator = 0, 0
    for j in range(len(i)):
        if numerator == 0 and chislit.get(i[j]):
            numerator += chislit[i[j]]
        # elif :
        #     numerator += digit[i[j]]
        elif digit.get(i[j]) and 1 <= digit[i[j]] <= 10:
            numerator += digit_1[i[j]]
        elif drob_for_10.get(i[j]):
            denumerator += drob_for_10[i[j]]
        elif digit_10.get(i[j]):
            denumerator += digit_10[i[j]]
        elif drob_for_1.get(i[j]):
            denumerator += drob_for_1[i[j]]
        elif drob.get(i[j]):
            denumerator += drob[i[j]]
        elif denumerator != 0:
            denumerator += drob[i[j]]
    return numerator, denumerator
def num_int(i):
    num = 0
    for j in range(len(i)):
        num += digit[i[j]]
    return num
def is_drob(k): #есть ли дробь во вводе если k == 0, проверяем первое число, если k == 1, проверяем второе число
    global znak_n
    if k == 0:
        for i in s[0]:
            if drob.get(i) or drob_for_1.get(i) or drob_for_10.get(i):
                return True
    if k == 1:
        for i in s[1]:
            if drob.get(i) or drob_for_1.get(i) or drob_for_10.get(i):
                return True
    return False
def check():
    global s, comb, znak_n, drob, numbers
    d_0 = is_drob(0)
    d_1 = is_drob(1)
    if s[0] in comb_op[:2]:
        iz, po = s.index('из'), s.index('по')
        numbers[0] = num_int(s[iz+1: po-1]) + comb_op[s[po-1]]
        numbers[1] = num_int(s[po+1:])
        return 'comb'
    elif s[0] == 'перестановок':
        po = s.index('по')
        numbers[0] = num_int(s[po+1:])
        return 'comb'
    elif d_0 and d_1:
        numbers = [enum(s[0]), enum(s[1])]
        return 'drobi'
    elif d_0:
        numbers = [enum(s[0]), num_int(s[1])]
        return '1drob'
    elif d_1:
        numbers = [num_int(s[0]), enum(s[1])]
        return '2drob'
    else:
        numbers[0], numbers[1]  = num_int(s[0]), num_int(s[1])
        return 'int'


def nod(i, j): #ищем НОД двух чисел
    if i == 0:
        return j
    return nod(j % i, i)
def fac(i): #ищем факториал i
    if i == 1:
        return 1
    return i*fac(i-1)
def drobi(n1, n2): #выполняем действие между двумя дробями
    numerator_1, denumerator_1 = n1
    numerator_2, denumerator_2 = n2
    if znak_z == 'плюс':
        numerator_1 = numerator_1 * denumerator_2 + numerator_2 * denumerator_1
        denumerator_1 *= denumerator_2
    elif znak_z == 'минус':
        numerator_1 = numerator_1 * denumerator_2 - numerator_2 * denumerator_1
        denumerator_1 *= denumerator_2
    elif znak_z == 'умножить':
        numerator_1 *= numerator_2
        denumerator_1 *= denumerator_2
    elif znak_z == 'разделить':
        numerator_1 *= denumerator_2
        denumerator_1 *= numerator_2
    obd = nod(numerator_1, denumerator_1)
    numerator, denumerator = numerator_1 // obd, denumerator_1 // obd
    return numerator, denumerator
def operation_between(i, j):
    if znak_z == 'плюс':
        return i+j
    if znak_z == 'минус':
        return i-j
    if znak_z == 'умножить':
        return i*j
def calcul(s): #определяем, какую операцию хочет сделать пользователь
    global numbers
    if check() == 'comb':
        if s[0] == 'размещений':
            return fac(numbers[0])//fac(numbers[0]-numbers[1])
        if s[0] == 'сочетаний':
            return fac(numbers[0])//(fac(numbers[0]-numbers[1])* fac(numbers[1]))
        if s[0] == 'перестановок':
            return fac(numbers[0])
    elif check() == 'drobi':
        return drobi(numbers[0], numbers[1])
    elif check() == '1drob':
        return drobi(numbers[0], (numbers[1]*numbers[0][1], numbers[0][1]))
    elif check() == "2drob":
        return drobi((numbers[0] * numbers[1][1], numbers[1][1]), numbers[1] )
    elif check() == 'int':
        return operation_between(numbers[0], numbers[1])

def inp_int(m):
    if m//10 == 1: return [digit_obr[m]]
    if m // 10 == 0: return [digit_obr[m % 10]]
    if m%10 == 0: return [digit_obr[m//10]]
    return [digit_obr[m // 10], digit_obr[m % 10]]
def posle():
    global m, posl
    if m[0] % m[1] == 1:
        if len(m[1]) > 1:
            posl = drob_for_obr[m[1][-1]]
        else:
            posl = drob_for_obr[m[1]]
    else:
        if len(m[1]) > 1:
            posl = drob_obr[m[1][-1]]
        else:
            posl = drob_obr[m[1]]
def num_ne_100(i):
    return i < 100
def num_znak(i):
    if isinstance(i, int):
        if i < 0:
            return '-', abs(i)
        return '+', i
    else:
        if i[0] < 0 or i[1] < 0:
            return '-', abs(i[0]), abs(i[1])
        return '+', abs(i[0]), abs(i[1])
def pretty_drob(i):
    i = list(i)
    zel = inp_int(i[0] // i[1]) + ['и']
    i[0] %= i[1]
    znamenat = inp_int(i[1])
    if i[1] // 10 != 1:
        if i[0] % 10 != 1: znamenat[-1] = drob_obr[i[1] % 10]
        else: znamenat[-1] = drob_for_obr[i[1] % 10]
    chisl = inp_int(i[0])
    if i[0]//10 != 1:
        chisl[-1] = chislit_obr[i[0]%10]
    return zel+chisl+znamenat


def calc(m):
    k = (check() not in ['drobi', '1drob', '2drob'])
    if not k and (m[0] % m[1] == 0):
        k = 1
        m = m[0]//m[1]
    if k :
        if m > 100: return [m]
        if m<0: return ['минус', inp_int(abs(m))]
        return inp_int(m)

    else:
        if m[0]<0 or m[1]<0:
            m = list(m)
            m[0], m[1] = abs(m[0]), abs(m[1])
            a = ['минус'] + pretty_drob(m)
            return a
        return pretty_drob(m)


chislit = {'одна': 1, 'две': 2}
drob_1 = {'первых': 1, 'вторых': 2, 'третьих': 3, 'четвертых': 4, 'пятых': 5, 'шестых': 6, 'седьмых': 7, 'восьмых': 8,
          'девятых': 9}
drob_for = {}
drob_for_1 = {'первая': 1, 'вторая': 2, 'третья': 3, 'четвертая': 4, 'пятая': 5, 'шестая': 6, 'седьмая': 7, 'восьмая': 8,
          'девятая': 9}
drob_for_10 = {'десятая': 10, 'одиннадцатая': 11, 'двенадцатая': 12, 'тринадцатая': 13, 'четырдцатая': 14,
           'пятнадцатая': 15, 'сотая': 100,
           'шестнадцатая': 16, 'семнадцатая': 17, 'восемнадцатая': 18, 'девятнадцатая': 19, 'двадцатая': 20,
           'тридцатая': 30,
           'сороковая': 40, 'пятидесятая': 50, 'шестидесятая': 60, 'семидесятая': 70, 'восьмидесятая': 80,
           'девяностая': 90}
drob_for.update(drob_for_1)
drob_for.update(drob_for_10)

drob_10 = {'десятых': 10, 'одиннадцатых': 11, 'двенадцатых': 12, 'тринадцатых': 13, 'четырдцатых': 14,
           'пятнадцатых': 15, 'сотых': 100,
           'шестнадцатых': 16, 'семнадцатых': 17, 'восемнадцатых': 18, 'девятнадцатых': 19, 'двадцатых': 20,
           'тридцатых': 30,
           'сороковых': 40, 'пятидесятых': 50, 'шестидесятых': 60, 'семидесятых': 70, 'восьмидесятых': 80,
           'девяностых': 90}
drob = {}
drob.update(drob_1)
drob.update(drob_10)
digit_1 = {'ноль': 0, 'один': 1, 'два': 2, 'три': 3, 'четыре': 4, 'пять': 5, 'шесть': 6, 'семь': 7, 'восемь': 8, 'девять': 9}
digit_10 = {'десять': 10, 'одиннадцать': 11, 'двенадцать': 12, 'тринадцать': 13, 'четырнадцать': 14, 'пятнадцать': 15,
            'шестнадцать': 16, 'семнадцать': 17, 'восемнадцать': 18, 'девятнадцать': 19, 'двадцать': 20, 'тридцать': 30,
            'сорок': 40, 'пятьдесят': 50, 'шестьдесят': 60, 'семьдесят': 70, 'восемьдесят': 80, 'девяносто': 90,
            'сто': 100}
digit_100 = {'сто': 100, 'двести': 200, 'триста': 300, 'четыреста': 400, 'пятьсот': 500, 'шестьсот': 600,
             'семьсот': 700, 'восемьсот': 800, 'девятьсот': 900}
digit_1000 = {'тычяча': 1000, 'две тысячи': 2000, 'три тысячи': 3000, 'четыре тысячи': 4000, 'пять тысяч': 5000,
              'шесть тысяч': 6000, 'семь тысяч': 7000, 'восемь тысяч': 8000, 'девять тысяч': 9000,
              'десять тысяч': 10000}
digit ={}
digit.update(digit_1)
digit.update(digit_10)
digit.update(digit_100)
digit.update(digit_1000)


digit_obr = {b: a for a, b in digit.items()}
drob_obr = {b: a for a, b in drob.items()}
drob_for_obr = {b: a for a, b in drob_for.items()}
chislit = { 'одна': 1, 'две': 2, 'три': 3, 'четыре': 4, 'пять': 5, 'шесть': 6, 'семь': 7, 'восемь': 8, 'девять': 9,
            'десять': 10, 'одиннадцать': 11, 'двенадцать': 12, 'тринадцать': 13, 'четырнадцать': 14, 'пятнадцать': 15,
            'шестнадцать': 16, 'семнадцать': 17, 'восемнадцать': 18, 'девятнадцать': 19, 'двадцать': 20, 'тридцать': 30,
            'сорок': 40, 'пятьдесят': 50, 'шестьдесят': 60, 'семьдесят': 70, 'восемьдесят': 80, 'девяносто': 90,
            'сто': 100}
chislit_obr = {b: a for a, b in chislit.items()}
znak = ["плюс", "минус", "умножить", "разделить"]

comb_op = ['размещений', 'сочетаний', 'перестановок']
comb_1 = {'одного':1 , 'двух':2  ,'трех': 3 , 'четырех':4 , 'пяти':5 , 'шести':6 , 'семи':7 , 'восьми':8 , 'девяти': 9 }
comb_10 = {'десяти': 10, 'одиннадцати': 11 ,'двенадцати':12 , 'тринадцати':13 , 'четырнадцати':14 , 'пятнадцати':15 , 'шестнадцати': 16,
          'семнадцати': 17 , 'восемнадцати': 18, 'девятнадцати': 19, 'двадцати':20 , 'тридцати':30 ,'сорока':40, 'пятидесяти': 50,
           'шестидесяти': 60 , 'семидесяти':70 , 'восьмидесяти':80 , 'девяноста': 90, 'ста': 100}
comb = comb_1
comb.update(comb_10)


while True:
    s = input().replace(' на ', ' ').split()
    print(s)
    znak_n, znak_z = 0, 0
    # print(znak_n, znak_z)
    numbers = [0, 0]
    pretty_num()
    print(s)
    print(check())
    print(*numbers)
    print(calcul(s))
    print(numbers)
    print(calcul(s))
    print(*calc(calcul(s)))