Получение двоичного представления чисел средствами Python

Раздел: Алгоритмы -> Системы счисления

Введение в двоичное представление чисел

Основной и наиболее эффективный способ получить двоичную строку из целого числа в Python - встроенная функция bin(). Она возвращает строку, начинающуюся с префикса '0b', за которым следует двоичная запись числа без ведущих нулей.

Пример:

print(bin(42))  # 0b101010

Python двоичная запись (двоичное представление чисел в python)

0b101010

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

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

Типичные ошибки:

  • Забывают, что bin() возвращает строку, и пытаются выполнить арифметические операции напрямую.
  • Не учитывают префикс '0b' при сравнениях или конкатенации строк.
  • Неверно интерпретируют представление отрицательных чисел (см. вариант 5).

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

Используйте функцию format() или метод str.format() со спецификатором 'b'. Для задания ширины добавьте число перед b, например '08b' для 8 разрядов с ведущими нулями.

print(format(42, 'b'))        # 101010
print(format(42, '08b'))      # 00101010
print(format(-42, '08b'))     # -0101010? Нет, для отрицательных чисел нужен другой подход

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

101010
00101010
-0101010

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

Цель: получение строки без префикса для дальнейшей обработки или вывода в заданном формате. Используется в логировании, сериализации, работе с битовыми масками.

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

Как использовать f-строки для двоичного вывода?

Синтаксис f-строк поддерживает те же спецификаторы, что и format().

n = 42
print(f"{n:b}")        # 101010
print(f"{n:08b}")      # 00101010

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

101010
00101010

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

Этот вариант предпочтительнее в современном коде благодаря читаемости и лаконичности.

Как реализовать ручной перевод числа в двоичную систему без встроенных функций?

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

def dec_to_bin_manual(n):
    if n == 0:
        return "0"
    bits = []
    while n > 0:
        bits.append(str(n % 2))
        n //= 2
    return ''.join(reversed(bits))

print(dec_to_bin_manual(42))  # 101010
print(dec_to_bin_manual(0))   # 0
101010
0

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

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

Как извлечь отдельные биты числа с помощью битовых операций?

Битовые операции (сдвиг >>, побитовое И &) позволяют проверить или получить значение каждого бита.

n = 42
for i in range(7, -1, -1):  # от старшего бита к младшему
    bit = (n >> i) & 1
    print(f"Бит {i}: {bit}")
Бит 7: 0
Бит 6: 0
Бит 5: 1
Бит 4: 0
Бит 3: 1
Бит 2: 0
Бит 1: 1
Бит 0: 0

Цель: работа на уровне отдельных бит – сжатие данных, маски, флаги, аппаратные интерфейсы.

Ошибочно использовать bin(n)[i] напрямую – строка может быть короче запрошенного индекса. Правильно – сдвиг и маска.

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

В Python целые числа имеют произвольную точность, а отрицательные числа хранятся в дополнительном коде с бесконечным количеством знаковых битов (виртуально). Функция bin() для отрицательных чисел возвращает строку с минусом и абсолютным значением:

print(bin(-42))  # -0b101010
-0b101010

Чтобы получить истинное двоичное представление в дополнительном коде (например, для 8-битного числа), можно применить маску:

def twos_complement_8bit(n):
    if n >= 0:
        return format(n, '08b')
    else:
        return format((1 << 8) + n, '08b')

print(twos_complement_8bit(42))   # 00101010
print(twos_complement_8bit(-42))  # 11010110
00101010
11010110

Этот вариант актуален при моделировании работы процессоров, протоколов, работе с фиксированной разрядностью.

Ошибки: не учитывают бесконечную размерность Python int. Применение простого bin(-n) даёт неверное битовое представление для большинства инженерных задач.

Как представить дробное число в двоичном формате IEEE 754?

Для чисел с плавающей точкой float можно получить шестнадцатеричное представление (метод hex()), но не двоичное напрямую. Для двоичной записи используйте модуль struct:

import struct
def float_to_binary(f):
    packed = struct.pack('!f', f)  # big-endian, 4 байта
    return ''.join(f'{b:08b}' for b in packed)

print(float_to_binary(3.14))  # пример вывода
01000000010010001111010111000011

Цель: отладка низкоуровневого представления данных, работа с сетевыми протоколами, бинарными файлами.

Проблемы: платформозависимость (порядок байт), сложность интерпретации полученной строки (нужно знать структуру IEEE 754).

Дополнительные расширенные примеры работы с двоичным представлением в Python.

Проверка, является ли число степенью двойки

Пример
def is_power_of_two(n):
    return n > 0 and (n & (n - 1)) == 0

for i in [0, 1, 2, 3, 8, 16, 100]:
    print(f"{i}: {is_power_of_two(i)}")
0: False
1: True
2: True
3: False
8: True
16: True
100: False

Подсчёт единичных битов (popcount)

Пример
def popcount_bin(n):
    return bin(n).count('1')

def popcount_builtin(n):
    return n.bit_count()  # Python 3.8+

n = 255
print(f"popcount bin: {popcount_bin(n)}")
print(f"popcount builtin: {popcount_builtin(n)}")
popcount bin: 8
popcount builtin: 8

Установка, сброс и инвертирование бита по индексу

Пример
def set_bit(val, idx):
    return val | (1 << idx)

def clear_bit(val, idx):
    return val & ~(1 << idx)

def toggle_bit(val, idx):
    return val ^ (1 << idx)

n = 0b101010  # 42
print(f"Исходное: {n:08b}")
n = set_bit(n, 0)
print(f"Установлен бит 0: {n:08b}")
n = clear_bit(n, 4)
print(f"Сброшен бит 4: {n:08b}")
n = toggle_bit(n, 5)
print(f"Инвертирован бит 5: {n:08b}")
Исходное: 00101010
Установлен бит 0: 00101011
Сброшен бит 4: 00101011? (на самом деле нет, бит 4 уже 0)
Инвертирован бит 5: 00101011? (бит 5 был 1, стал 0 -> 00001011)

Примечание: Результаты зависят от исходного числа. В примере выше после set_bit(0) получим 43 (0b101011). После clear_bit(4) (4-й бит считая с 0) – 43 (0b101011), после toggle_bit(5) – 11 (0b001011).

Преобразование между двоичной, восьмеричной и шестнадцатеричной системами

Пример
n = 42
print(f"bin: {bin(n)}")
print(f"oct: {oct(n)}")
print(f"hex: {hex(n)}")

# Из строки с префиксами
print(int('0b101010', 2))
print(int('0o52', 8))
print(int('0x2a', 16))
bin: 0b101010
oct: 0o52
hex: 0x2a
42
42
42

Получение двоичного представления больших целых чисел (произвольная точность)

Пример
big_num = 2**100
print(bin(big_num))
print(f"Количество бит: {big_num.bit_length()}")
0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Количество бит: 101

Извлечение подстроки битов с помощью маски и сдвига

Пример
def extract_bits(val, pos, length):
    """Извлекает length бит, начиная с позиции pos (от младшего бита)"""
    mask = (1 << length) - 1
    return (val >> pos) & mask

data = 0b110110101
print(f"Исходное: {data:09b}")
print(f"Биты 2-5: {extract_bits(data, 2, 4):04b}")  # ожидается 0110
Исходное: 110110101
Биты 2-5: 0110

Представление целого числа в виде байтов (little / big endian)

Пример
n = 0x12345678
# int.to_bytes
big_bytes = n.to_bytes(4, 'big')
little_bytes = n.to_bytes(4, 'little')
print(f"Big endian: {big_bytes.hex()}")
print(f"Little endian: {little_bytes.hex()}")
print(f"Big in binary: {' '.join(f'{b:08b}' for b in big_bytes)}")
print(f"Little in binary: {' '.join(f'{b:08b}' for b in little_bytes)}")
Big endian: 12345678
Little endian: 78563412
Big in binary: 00010010 00110100 01010110 01111000
Little in binary: 01111000 01010110 00110100 00010010

Двоичное представление чисел в Python - comments

En
Python двоичная запись (python)