Recurse Match

Roman Numerals
Roman Numerals in Python 
ARABIC_NUM = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)
ROMAN_NUM = ("M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I")

def roman(number: int) -> str:
    return roman_recur(number, 0, [])

def roman_recur(num: int, idx: int, digits: list[str]):
    match (num, idx, digits):
        case [_, 13, digits]:
            return ''.join(digits[::-1])
        case [num, idx, digits] if num >= ARABIC_NUM[idx]:
            return roman_recur(num - ARABIC_NUM[idx], idx, [ROMAN_NUM[idx],] + digits)
        case [num, idx, digits]:
            return roman_recur(num, idx + 1, digits)

Recursion is possible in Python, but it is much less commonly used than in some other languages.

A limitation is the lack of tail-recursion optimization, which can easily trigger stack overflow if the recursion goes too deep. The maximum recursion depth for Python defaults to 1000 to avoid this overflow.

However, Roman numerals are so limited in scale that they could be an ideal use case for playing with recursion. In practice, there is no obvious advantage to recursion over using a loop (everything you can do with recursion you can do with a loop and vice-versa) .

Note the use of structural pattern matching, available in Python since version 3.10. There is also an official tutorial for this new feature.

The code above is adapted from a Scala approach, where it may be more appropriate.

Once we get past the unfamiliar-in-Python syntax, this code is doing essentially the same as other loop-over-romans approaches.

Without the pattern matching, a recursive approach might look something like this:

LOOKUP = [(1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"),
    (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I")]

def convert (number, idx, output):
    if idx > 12:
        return output
    val, ltr = LOOKUP[idx]
    if number >= val:
        return convert(number - val, idx, output + ltr)
    return convert(number, idx + 1, output)

def roman(number):
    return convert(number, 0, "")
8th May 2024 · Found it useful?

Other Approaches to Roman Numerals in Python

Other ways our community solved this exercise
def translate_digit(digit: int, translations: iter) -> str:
        units, four, five, nine = translations
        if digit < 4: return digit * units
        if digit == 4: return four
        if digit < 9: return five + (digit - 5) * units
        return nine
        
    if c > 0: res += translate_digit(c, ('C', 'CD', 'D', 'CM'))
If Else

Use booleans to find the correct translation for each digit. 

def roman(number):
    assert(number > 0)
    roman_num = ""
    for (k, v) in ROMANS:
        while k <= number:
            roman_num += v
            number -= k
    return roman_num
Loop Over Romans

Test Roman Numerals from the largest down and eat the maximum possible at each step. 

table = (
        ("I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"),
        ("X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"),
        ("C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"),
        ("M", "MM", "MMM"))
    digits = [int(d) for d in str(number)][::-1]
    roman_digits = [table[i][d - 1] for (i, d) in enumerate(digits) if d != 0]
    return ''.join(roman_digits[::-1])
Table Lookup

Use a 2-D lookup table to eliminate loop nesting. 

from itertools import starmap

def roman(number: int) -> str:
    orders = [(1000, "M  "), (100, "CDM"), (10, "XLC"), (1, "IVX")] 
    options = lambda I, V, X: ["", I, I * 2, I * 3, I + V, V, V + I, V + I * 2, V + I * 3, I + X]
    compute = lambda n, chars: options(*chars)[number % (n * 10) // n]
    return "".join(starmap(compute, orders))
Itertools Starmap

Use itertools.starmap() for an ingenious functional approach.