Perform a replacement on a string with several calls to the re.sub() method in a specific order and conditioned by these regex

Going both ways:

import re

NUMBERS = [
    (10**15, 'quatrillon', 'es', False),
    (10**12, 'trillon', 'es', False),
    (10**9, 'billon', 'es', False),
    (10**6, 'millon', 'es', False),
    (10**3, 'mil', '', True)
]


def num_to_name(n):
    n = int(n) if isinstance(n, str) else n

    for size, name, multi, alone in NUMBERS:
        if n > size - 1:
            n = n // size
            if n == 1 and alone:
                return f'{name}'
            else:
                return f'{n} {name}{multi if n > 1 else ""}'
    return str(n)


def name_to_num(s, return_f=False):
    s = s[:-2] if s.endswith('es') else s
    for size, name, _, alone in NUMBERS:
        if s.lower().endswith(name):
            result = int(s[:-(len(name) + 1)]) * size if not alone or s.lower() != name else size
            return (result, size) if return_f else result
    return (int(s), 0) if return_f else int(s)


input_str = "creo que hay 330 trillones 2 billones 18 millones 320 mil 459 47475822 1000"
num_str = re.sub('d+(?: (?:quatr|tr|b|m)illon(?:es)?| mil)?|mil',
                 lambda match: str(name_to_num(match.group(0))), input_str)
print(num_str)

name_str = re.sub('d+',
                  lambda match: num_to_name(match.group(0)), num_str)
print(name_str)

Output:

creo que hay 330000000000000 2000000000 18000000 320000 459 47475822 1000
creo que hay 330 trillones 2 billones 18 millones 320 mil 459 47 millones mil

Note that the final result is not exactly the input string, since the input string had some numbers that could be converted (like '47 millones'). Also, you indicated that 1 mil is written as mil, so an additional field was added to NUMBERS to flag that, and num_to_name() adjusted to deal with that case.

The function num_to_name(n) takes an integer (or string, converted to an integer) and finds the appropriate way to write it as a number, using the naming defined in NUMBERS. If it doesn’t match any of the sizes, it just returns the number as a string.

The function name_to_num(s) takes a string and checks whether it ends in any of the names (with or without plural) defined in NUMBERS. If it does, it tries to convert the rest of the string into an integer and returns that value multiplied by the matching factor. Otherwise, it tries to just return the integer value of the string.

At the bottom, there’s two regexes matching the relevant parts of the input string, using a lambda to replace the found fragments using the 2 functions.

From your comment, I noted that you actually want subsequent matches decreasing in size to be combined into a single number – the below doesn’t answer that, I’ll leave the code all the same)

This additional code does that, together with the first part:

def full_name_to_num(s):
    subs = []
    last_f = 0

    def sub(s):
        s, end = (s[:-1], ' ') if s[-1] == ' ' else (s, '')
        nonlocal last_f
        n, f = name_to_num(s, True)
        if subs and (f < last_f):
            subs[-1] = subs[-1] + n
            result = ''
        else:
            subs.append(n)
            result = str(len(subs)-1) + end
        last_f = f
        return result

    temp = re.sub('(?:d+(?: (?:quatr|tr|b|m)illon(?:es)?| mil)?|mil) ?', lambda match: sub(match.group(0)), s)
    return re.sub('d+', lambda match: str(subs[int(match.group(0))]), temp)


def full_num_to_name(s):
    def sub(s):
        n = int(s)
        result = [str(n % NUMBERS[-1][0])] if n % NUMBERS[-1][0] else []
        for size, _, _, _ in reversed(NUMBERS):
            if (n // size) % 1000:
                result.append(num_to_name(n % (size * 1000)))
        return ' '.join(reversed(result))

    return re.sub('d+', lambda match: sub(match.group(0)), s)


input_str = "creo que hay 330 trillones 2 billones 18 millones 320 mil 459 47475822"
full_num_str = full_name_to_num(input_str)
print(full_num_str)

full_name_str = full_num_to_name(full_num_str)
print(full_name_str)

Extra output:

creo que hay 330002018320459 47475822
creo que hay 330 trillones 2 billones 18 millones 320 mil 459 47 millones 475 mil 822