Единственная функция для преобразования десятичных значений в двоичные, шестнадцатеричные и восьмеричные не преобразуется в двоичные

Ваш elif лишний - если вы сделаете %2, результат может быть только 0 или 1 - не нужно обрабатывать его по-другому.

Ваш код не преобразует все число - вы проверяете модуль числа, а не то, как часто в него вписывается ваша база (и более высокие степени вашей базы).

Вам нужно получить максимально возможную мощность для вашей базы, которая вписывается в ваше число. Затем вам нужно узнать, как часто это число вписывается в ваше число, вычесть его из числа и продолжить оставшуюся часть этой операции. Вы уменьшаете свою силу на единицу и продолжаете, пока ваше число не станет равным 0. Затем вы складываете все числа в строку.

Ваш код исправлен:

def convert(num, base):
    # get the highest power
    power = 0
    while num // (base**(power+1)) > 0:
        power += 1

    # divide, remember, subtract - until down to the lowest power
    result = []
    while num >= 0:
        p = base**power
        if p == 1:
            result.append(num)
            break
        result.append(num // p)
        num -= result[-1]*p
        power -= 1

    return ''.join(map(str,result))

чтобы получить вывод:

1 1 1 1
2 2 2 10
3 3 3 11
4 4 4 100
5 5 5 101
6 6 6 110
7 7 7 111
8 10 8 1000
9 11 9 1001
10 12 10 1010
11 13 11 1011
12 14 12 1100
13 15 13 1101
14 16 14 1110
15 17 15 1111
16 20 10 10000

Или вы используете встроенные функции:

def make(i):
    for k in range(i+1):
        print(f"{k:>10} {bin(k):>10} {hex(k):>10} {oct(k):>10}")
        # or slice away the prefixes:
        # print(f"{k:>10} {bin(k)[2:]:>10} {hex(k)[2:]:>10} {oct(k)[2:]:>10}")


make(17)

Результат:

         0        0b0        0x0        0o0
         1        0b1        0x1        0o1
         2       0b10        0x2        0o2
         3       0b11        0x3        0o3
         4      0b100        0x4        0o4
         5      0b101        0x5        0o5
         6      0b110        0x6        0o6
         7      0b111        0x7        0o7
         8     0b1000        0x8       0o10
         9     0b1001        0x9       0o11
        10     0b1010        0xa       0o12
        11     0b1011        0xb       0o13
        12     0b1100        0xc       0o14
        13     0b1101        0xd       0o15
        14     0b1110        0xe       0o16
        15     0b1111        0xf       0o17
        16    0b10000       0x10       0o20
        17    0b10001       0x11       0o21

Проблема в том, что вы берете только мод вашего числа (num % base), то есть самый правый («наименее значащий») бит. Нам нужен не самый младший бит, а вся декомпозиция.

NB: проблема здесь применима и ко всем другим основаниям (десятичным, шестнадцатеричным...).

Действительно, если запустить

n = 1000
print_formatted(n)

с вашими функциями вы получаете, что разложение 1000 по разным основаниям:

1000 0 8 0

(все они неверны).

Здесь я предлагаю рекурсивную реализацию:

def convert(integerToConvert, base = 2):
    '''
    When given a num and a base, will get the 
    conversion of that number in that base
    '''

    # The negative integer case is not taken into account
    if (integerToConvert < 0):
        print("ERROR: INTEGER < 0")
        return;

    # When the integer is 0, we know that we are done. There is no more bit
    if (integerToConvert == 0):
        print("WE ARE DONE")
        return;

    # get the current least significant coeff in the integerToEncode
    currentLeastSignificant = integerToConvert % base;
    print(currentLeastSignificant)

    # remove the least significant coeff and start again
    convert((integerToConvert - currentLeastSignificant) / base, base)

Я провел несколько быстрых тестов:

convert(17, 2)
1
0.0
0.0
0.0
1.0
WE ARE DONE

convert(16, 2)
0
0.0
0.0
0.0
1.0
WE ARE DONE

convert(17, 16)
1
1.0
WE ARE DONE

NB1: я печатаю числа, но вы можете хранить их в структуре данных по вашему выбору.

NB2: Самый значимый коэффициент печатается последним (можно сравнить с ожидаемым результатом)

NB3: все эти вычисления немного дороги, поэтому, если для вас важна скорость, лучше всего хранить все разложения в массивах и обращаться к ним (постоянное время).