Преобразовать шестнадцатеричный код в двоичный

Для решения задачи с левым конечным нулем:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)

Это даст 00011010 вместо урезанной версии.

import binascii

binary_string = binascii.unhexlify(hex_string)

Читать

binascii.unhexlify

Возвращает двоичные данные, представленные шестнадцатеричной строкой, указанной в качестве параметра.

Преобразовать шестнадцатеричный код в двоичный

У меня ABC123EFFF.

Я хочу иметь 0010101011110000010010001111101111111111111 (то есть двоичное представление, скажем, с 42 цифрами и ведущими нулями).

Короткий ответ:

Новые f-строки в Python 3.6 позволяют вам сделать это, используя очень лаконичный синтаксис:

>>> f'{0xABC123EFFF:0>42b}'
'001010101111000001001000111110111111111111'

или разбить это на семантику:

>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'{number:{pad}{rjust}{size}{kind}}'
'001010101111000001001000111110111111111111'

Длинный ответ:

На самом деле вы говорите, что у вас есть значение в шестнадцатеричном представлении, и вы хотите представить эквивалентное значение в двоичном формате.

Значение эквивалентности является целым числом. Но вы можете начать со строки, а для просмотра в двоичном виде вы должны закончить строкой.

Преобразовать шестнадцатеричный код в двоичный, 42 цифры и ведущие нули?

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

Во-первых, прежде чем мы сможем выполнять какие-либо бинарные манипуляции, преобразуйте их в int (я предполагаю, что это в строковом формате, а не как литерал):

>>> integer = int('ABC123EFFF', 16)
>>> integer
737679765503

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

>>> integer = 0xABC123EFFF
>>> integer
737679765503

Теперь нам нужно выразить наше целое число в двоичном представлении.

Используйте встроенную функцию format

Затем перейдите к format:

>>> format(integer, '0>42b')
'001010101111000001001000111110111111111111'

При этом используется мини-язык спецификации форматирования.

Чтобы разобрать это, вот его грамматическая форма:

[[fill]align][sign][#][0][width][,][.precision][type]

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

>>> spec = '{fill}{align}{width}{type}'.format(fill='0', align='>', width=42, type='b')
>>> spec
'0>42b'

и просто передайте это для форматирования

>>> bin_representation = format(integer, spec)
>>> bin_representation
'001010101111000001001000111110111111111111'
>>> print(bin_representation)
001010101111000001001000111110111111111111

Форматирование строк (шаблон) с помощью str.format

Мы можем использовать это в строке, используя метод str.format:

>>> 'here is the binary form: {0:{spec}}'.format(integer, spec=spec)
'here is the binary form: 001010101111000001001000111110111111111111'

Или просто поместите спецификацию прямо в исходную строку:

>>> 'here is the binary form: {0:0>42b}'.format(integer)
'here is the binary form: 001010101111000001001000111110111111111111'

Форматирование строк с новыми f-строками

Давайте продемонстрируем новые f-строки. Они используют одни и те же правила форматирования мини-языка:

>>> integer = 0xABC123EFFF
>>> length = 42
>>> f'{integer:0>{length}b}'
'001010101111000001001000111110111111111111'

Теперь давайте поместим эту функциональность в функцию, чтобы стимулировать повторное использование:

def bin_format(integer, length):
    return f'{integer:0>{length}b}'

И сейчас:

>>> bin_format(0xABC123EFFF, 42)
'001010101111000001001000111110111111111111'    

В стороне

Если вы на самом деле просто хотели закодировать данные в виде строки байтов в памяти или на диске, вы можете использовать метод int.to_bytes, который доступен только в Python 3:

>>> help(int.to_bytes)
to_bytes(...)
    int.to_bytes(length, byteorder, *, signed=False) -> bytes
...

И поскольку 42 бита, разделенные на 8 бит на байт, равны 6 байтам:

>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'

Используйте встроенную функцию format() и функция int() Это просто и понятно. Это немного упрощенная версия ответа Аарона

целое()

int(string, base)

формат()

format(integer, # of bits)

Пример

# w/o 0b prefix
>> format(int("ABC123EFFF", 16), "040b")
1010101111000001001000111110111111111111

# with 0b prefix
>> format(int("ABC123EFFF", 16), "#042b")
0b1010101111000001001000111110111111111111

# w/o 0b prefix + 64bit
>> format(int("ABC123EFFF", 16), "064b")
0000000000000000000000001010101111000001001000111110111111111111

См. также этот ответ

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

Ключевой момент для понимания:

(n & (1 << i)) and 1

Который будет генерировать либо 0, либо 1, если установлен i-й бит n.

import binascii

def byte_to_binary(n):
    return ''.join(str((n & (1 << i)) and 1) for i in reversed(range(8)))

def hex_to_binary(h):
    return ''.join(byte_to_binary(ord(b)) for b in binascii.unhexlify(h))

print hex_to_binary('abc123efff')

>>> 1010101111000001001000111110111111111111

Изменить: используя «новый» тернарный оператор:

(n & (1 << i)) and 1

Станет:

1 if n & (1 << i) or 0

(Какой TBH, я не уверен, насколько это читабельно)

Это небольшое дополнение к решению Глена Мейнарда, и я думаю, что это правильный способ сделать это. Он просто добавляет элемент заполнения.

    def hextobin(self, hexval):
        '''
        Takes a string representation of hex data with
        arbitrary length and converts to string representation
        of binary.  Includes padding 0s
        '''
        thelen = len(hexval)*4
        binval = bin(int(hexval, 16))[2:]
        while ((len(binval)) < thelen):
            binval = '0' + binval
        return binval

Вытащил из класса. Просто уберите self, , если вы работаете в автономном сценарии.

Замените каждую шестнадцатеричную цифру соответствующими 4 двоичными цифрами:

1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111

шестнадцатеричный --> десятичный, затем десятичный --> двоичный

#decimal to binary 
def d2b(n):
    bStr = ''
    if n < 0: raise ValueError, "must be a positive integer"
    if n == 0: return '0'
    while n > 0:
        bStr = str(n % 2) + bStr
        n = n >> 1    
    return bStr

#hex to binary
def h2b(hex):
    return d2b(int(hex,16))

Я добавил расчет количества битов для заполнения в решение Onedinkenedi. Вот результирующая функция:

def hextobin(h):
  return bin(int(h, 16))[2:].zfill(len(h) * 4)

Где 16 — это основание, из которого вы конвертируете (шестнадцатеричное), а 4 — это количество битов, необходимых для представления каждой цифры, или логарифмическое основание 2 шкалы.

По-другому:

import math

def hextobinary(hex_string):
    s = int(hex_string, 16) 
    num_digits = int(math.ceil(math.log(s) / math.log(2)))
    digit_lst = ['0'] * num_digits
    idx = num_digits
    while s > 0:
        idx -= 1
        if s % 2 == 1: digit_lst[idx] = '1'
        s = s / 2
    return ''.join(digit_lst)

print hextobinary('abc123efff')

Просто используйте модуль coden ^{(примечание: я автор модуля)}

Там вы можете преобразовать шестнадцатеричное число в двоичное.

1. Установить с помощью pip

pip install coden

2. Конвертировать

a_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)

Конверсионные ключевые слова:

• hex для шестнадцатеричных чисел
• bin для двоичного файла
• int для десятичного числа
• _to_ — ключевое слово преобразования для функции.

Таким образом, вы также можете форматировать: e. шестнадцатеричный_выход = bin_to_hex (a_binary_number)

HEX_TO_BINARY_CONVERSION_TABLE = {
                              '0': '0000',

                              '1': '0001',

                              '2': '0010',

                              '3': '0011',

                              '4': '0100',

                              '5': '0101',

                              '6': '0110',

                              '7': '0111',

                              '8': '1000',

                              '9': '1001',

                              'a': '1010',

                              'b': '1011',

                              'c': '1100',

                              'd': '1101',

                              'e': '1110',

                              'f': '1111'}

def hex_to_binary(hex_string):
    binary_string = ""
    for character in hex_string:
        binary_string += HEX_TO_BINARY_CONVERSION_TABLE[character]
    return binary_string

когда я время hex_to_binary("123ade")

  %timeit hex_to_binary("123ade")

вот результат:

 316 ns ± 2.52 ns per loop

В качестве альтернативы вы можете использовать метод соединения:

def hex_to_binary_join(hex_string):
    hex_array=[]
    for character in hex_string:
        hex_array.append(HEX_TO_BINARY_CONVERSION_TABLE[character])
    return "".join(hex_array)

Я тоже засекал это:

    %timeit hex_to_binary_join("123ade")
       397 ns ± 4.64 ns per loop 

у меня есть короткая надежда, которая помогает :-)

input = 'ABC123EFFF'
for index, value in enumerate(input):
    print(value)
    print(bin(int(value,16)+16)[3:])

string = ''.join([bin(int(x,16)+16)[3:] for y,x in enumerate(input)])
print(string)

сначала я использую ваш ввод и перечисляю его, чтобы получить каждый символ. затем я конвертирую его в двоичный файл и обрезаю с 3-й позиции до конца. Хитрость, чтобы получить 0, состоит в том, чтобы добавить максимальное значение ввода -> в этом случае всегда 16 :-)

краткая форма - это метод соединения. Наслаждаться.

Двоичная версия ABC123EFFF на самом деле 1010101111000001001000111110111111111111

Почти для всех приложений вы хотите, чтобы двоичная версия имела длину, кратную 4, с начальным дополнением 0.

Чтобы получить это в Python:

def hex_to_binary( hex_code ):
  bin_code = bin( hex_code )[2:]
  padding = (4-len(bin_code)%4)%4
  return '0'*padding + bin_code

Пример 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Пример 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Обратите внимание, что это также работает в Micropython :)