Перевод чисел: от двоичной до шестнадцатеричной системы с помощью Python

Дополнительные примеры с пояснениями

Перевод больших чисел в шестнадцатеричную систему

Функция hex() работает с целыми числами любой длины.

big = 10**100
print(hex(big))
# Результат (начало): '0x1249ad2594c37ceb0b2784c4ce0bf38ace40f8a2b8e...'

0x1249ad2594c37ceb0b2784c4ce0bf38ace40f8a2b8e9e5f0c7a0b8b2c8d4e6f0a0b0c0d0e0f0...

Обратное преобразование через int(s, 16) также корректно для строк любой длины.

Рекурсивная реализация перевода в двоичную систему

Рекурсия может быть наглядной для понимания, но имеет ограничение глубины стека.

def to_bin(n):
    if n == 0:
        return '0'
    if n == 1:
        return '1'
    return to_bin(n // 2) + str(n % 2)

print(to_bin(42))  # 101010

101010

Недостаток: для больших чисел может возникнуть переполнение стека. На практике лучше использовать цикл.

Обработка отрицательных чисел

Встроенные функции и ручные реализации корректно работают с отрицательными числами, сохраняя знак.

print(bin(-255))   # '-0b11111111'
print(oct(-255))   # '-0o377'
print(hex(-255))   # '-0xff'
print(int('-0b11111111', 2))  # -255

-0b11111111
-0o377
-0xff
-255

При ручной реализации знак сохраняется отдельно, как показано ранее.

Перевод дробных чисел (умножение дробной части)

Для перевода дробной части десятичного числа в другую систему используется последовательное умножение на основание.

def frac_to_base(f, base, precision=10):
    if f == 0:
        return '0'
    res = ''
    for _ in range(precision):
        f *= base
        digit = int(f)
        res += '0123456789ABCDEF'[digit]
        f -= digit
        if f == 0:
            break
    return res

# Перевод 0.625 в двоичную: 0.625*2=1.25 -> 1, 0.25*2=0.5 -> 0, 0.5*2=1.0 -> 1 -> 0.101
print(frac_to_base(0.625, 2))  # '101'

101

Целая и дробная части переводятся отдельно и объединяются через точку.

Использование format с префиксом и шириной для выравнивания

Часто требуется вывести числа в табличном виде с фиксированной шириной колонок.

values = [0, 15, 255, 1024]
for v in values:
    print(f"{v:>5} -> {v:08b} -> {v:#06x}")

    0 -> 00000000 -> 0x0000
   15 -> 00001111 -> 0x000f
  255 -> 11111111 -> 0x00ff
 1024 -> 100000000 -> 0x0400

Спецификатор :>5 выравнивает по правому краю шириной 5, :08b - двоичное с заполнением нулями до 8 символов, :#06x - шестнадцатеричное с префиксом и общей шириной 6.

Полноценная реализация base64 (без padding)

Base64 часто используется для кодирования бинарных данных, но можно реализовать и для целых чисел.

ALPHABET64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

def to_base64(n):
    if n == 0:
        return ALPHABET64[0]
    res = ''
    while n > 0:
        res = ALPHABET64[n % 64] + res
        n //= 64
    return res

def from_base64(s):
    return sum(ALPHABET64.index(ch) * (64 ** i) for i, ch in enumerate(reversed(s)))

print(to_base64(123456789))          # '7MqK'
print(from_base64('7MqK'))          # 123456789

7MqK
123456789

Важно: стандартный base64 добавляет символ '=' для выравнивания блоков, здесь реализована компактная версия без padding.

Перевод в римскую систему (непозиционная)

Хотя это выходит за рамки позиционных систем, для полноты можно упомянуть, как реализовать перевод в римские цифры. Однако в Python нет встроенной поддержки, и это требует специального алгоритма.

def to_roman(num):
    values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
    symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
    res = ''
    for v, s in zip(values, symbols):
        while num >= v:
            res += s
            num -= v
    return res

print(to_roman(2024))  # MMXXIV

MMXXIV

Данный пример показывает, что не все системы счисления являются позиционными, но Python позволяет реализовать любой алгоритм.