Как представить число в двоичной системе средствами Python

Как получить двоичную строку без префикса через format и f-строки?

Функция format и f-строки принимают спецификатор b. Этот способ дает строку без префикса и позволяет задавать ширину, выравнивание и ведущие нули.

n = 42
print(format(n, 'b'))
print(f'{n:b}')
print(f'{n:08b}')
print(format(n, '>10b'))
print(format(-42, 'b'))

перевод в десятичную систему счисления python (перевод числа в десятичную систему счисления в python)

101010
101010
00101010
    101010
-101010

перевод в троичную систему python (перевод числа в троичную систему в python)

Спецификатор 08b означает ширину 8 и заполнение нулями слева. Если число не помещается, ширина увеличивается. Для отрицательных чисел знак занимает отдельную позицию, а двоичные цифры не становятся дополнительным кодом.

Как перевести число в двоичную систему с помощью ручного деления на 2?

Алгоритм повторяет школьный метод: число делится на 2, остатки записываются, затем последовательность остатков переворачивается. Такой вариант полезен для понимания связи между десятичной и двоичной системами.

def to_binary_division(number):
    if number == 0:
        return '0'
    sign = '-' if number < 0 else ''
    n = abs(number)
    bits = []
    while n > 0:
        bits.append(str(n % 2))
        n //= 2
    return sign + ''.join(reversed(bits))

print(to_binary_division(42))
print(to_binary_division(255))
print(to_binary_division(-42))
print(to_binary_division(0))

функция перевода систем счисления python (функция перевода в любую систему счисления в python)

101010
11111111
-101010
0

Ключевые моменты: отдельная обработка нуля, работа с модулем числа для знака, обратный порядок остатков. Без переворота получается инвертированная строка.

Как выполнить перевод через битовые операции и сдвиг вправо?

Битовый сдвиг n >> 1 делит число на 2, а n & 1 извлекает младший бит. Этот метод ближе к низкоуровневым операциям и часто применяется в задачах с битовыми масками.

def to_binary_bitshift(number):
    if number == 0:
        return '0'
    sign = '-' if number < 0 else ''
    n = abs(number)
    bits = []
    while n:
        bits.append(str(n & 1))
        n >>= 1
    return sign + ''.join(reversed(bits))

print(to_binary_bitshift(42))
print(to_binary_bitshift(255))
print(to_binary_bitshift(-42))
print(to_binary_bitshift(0))

101010
11111111
-101010
0

Для отрицательных чисел в Python бесконечное знаковое расширение, поэтому прямое применение сдвига без abs дает неожиданные результаты. Модуль числа и отдельный знак решают эту задачу.

Как получить двоичное представление фиксированной длины с ведущими нулями?

Фиксированная длина нужна для протоколов, дампов, таблиц и битовых полей. В Python ширина задается в спецификаторе формата, например 08b или 016b.

values = [0, 5, 42, 255, 256]
for n in values:
    print(f'{n:08b}')

00000000
00000101
00101010
11111111
100000000

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

def twos_complement(value, bits=8):
    mask = (1 << bits) - 1
    return format(value & mask, f'0{bits}b')

print(twos_complement(5))
print(twos_complement(-5))
print(twos_complement(-1))

00000101
11111011
11111111

Как перевести вещественное число в двоичный вид?

Для float встроенная функция bin не работает. Один из вариантов - разложить число на целую и дробную части. Другой вариант - получить биты IEEE 754 через модуль struct.

def float_to_binary_manual(value, precision=12):
    if value == 0:
        return '0.0'
    sign = '-' if value < 0 else ''
    value = abs(value)
    integer = int(value)
    fraction = value - integer
    int_part = bin(integer)[2:]
    frac_bits = []
    for _ in range(precision):
        fraction *= 2
        bit = int(fraction)
        frac_bits.append(str(bit))
        fraction -= bit
        if fraction == 0:
            break
    if frac_bits:
        frac_str = ''.join(frac_bits)
        return f'{sign}{int_part}.{frac_str}'
    return f'{sign}{int_part}.0'

print(float_to_binary_manual(10.25))
print(float_to_binary_manual(0.1, 20))
print(float_to_binary_manual(-3.75))

1010.01
0.00011001100110011001
-11.11

Дробная часть часто не имеет конечной двоичной записи. Например, 0.1 в двоичном виде является периодической дробью. Параметр precision ограничивает количество битов после точки.

import struct

def float_to_bin64(value):
    packed = struct.pack('>d', value)
    integer = int.from_bytes(packed, 'big')
    return format(integer, '064b')

print(float_to_bin64(10.25))
print(float_to_bin64(-0.5))

0100000000100100100000000000000000000000000000000000000000000000
1011111111100000000000000000000000000000000000000000000000000000

Как перевести массив чисел в двоичные строки?

Для списков и других последовательностей удобны списковые включения и функция map. Результат можно сразу форматировать с нужной шириной.

numbers = [0, 1, 2, 3, 5, 8, 13]
binaries = [bin(n)[2:] for n in numbers]
print(binaries)

padded = [f'{n:08b}' for n in numbers]
print(padded)

mapped = list(map(lambda n: format(n, 'b'), numbers))
print(mapped)

['0', '1', '10', '11', '101', '1000', '1101']
['00000000', '00000001', '00000010', '00000011', '00000101', '00001000', '00001101']
['0', '1', '10', '11', '101', '1000', '1101']

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