Converter hex para binário

Eu tenho ABC123EFFF.

Eu quero ter 001010101111000001001000111110111111111111 (ou seja, repr. Binário com, digamos, 42 dígitos e zeros à esquerda).

Quão?

Para resolver o problema do zero à direita do lado esquerdo:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Ele dará 00011010 em vez da versão aparada.

import binascii

binary_string = binascii.unhexlify(hex_string)

Ler

binascii.unhexlify

Retorna os dados binários representados pela string hexadecimal especificada como o parâmetro.

bin(int("abc123efff", 16))[2:]

Converter hex para binário

Eu tenho ABC123EFFF.

Eu quero ter 001010101111000001001000111110111111111111 (ou seja, repr. Binário com, digamos, 42 dígitos e zeros à esquerda).

Resposta curta:

As novas strings F no Python 3.6 permitem que você faça isso usando uma sintaxe muito concisa:

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

ou para quebrar isso com a semântica:

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

Resposta longa:

O que você realmente está dizendo é que tem um valor em uma representação hexadecimal e deseja representar um valor equivalente em binário.

O valor de equivalência é um número inteiro. Mas você pode começar com uma string e, para visualizar em binário, deve terminar com uma string.

Converter hex para binário, 42 dígitos e zeros à esquerda?

Temos várias maneiras diretas de atingir esse objetivo, sem hackear usando fatias.

Primeiro, antes que possamos fazer qualquer manipulação binária, converta para int (presumo que seja em um formato de string, não como um literal):

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

como alternativa, podemos usar um literal inteiro expresso na forma hexadecimal:

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

Agora precisamos expressar nosso inteiro em uma representação binária.

Use a função embutida, format

Em seguida, passe para format:

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

Este utiliza da especificação formatação mini-linguagem .

Para quebrar isso, aqui está a forma gramatical disso:

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

Para tornar isso uma especificação para nossas necessidades, apenas excluímos as coisas de que não precisamos:

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

e apenas passar para formatar

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

Formatação de String (Templating) com str.format

Podemos usar isso em uma string usando o str.formatmétodo:

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

Ou apenas coloque a especificação diretamente na string original:

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

Formatação de string com as novas strings f

Vamos demonstrar as novas strings f. Eles usam as mesmas regras de formatação de minilinguagem:

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

Agora vamos colocar essa funcionalidade em uma função para incentivar a reutilização:

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

E agora:

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

a parte, de lado

Se você realmente deseja codificar os dados como uma string de bytes na memória ou no disco, pode usar o int.to_bytesmétodo, que só está disponível no Python 3:

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

E como 42 bits divididos por 8 bits por byte equivalem a 6 bytes:

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

"{0:020b}".format(int('ABC123EFFF', 16))

Esta é uma maneira bastante simples de fazer isso usando o bit fiddling para gerar as strings binárias.

O ponto chave para entender é:

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

O que gerará 0 ou 1 se o i'ésimo bit de n for definido.

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

Editar: usando o "novo" operador ternário isto:

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

Se tornaria:

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

(TBH, não tenho certeza se isso é legível)

Este é um pequeno toque na solução de Glen Maynard, que eu acho que é a maneira certa de fazer isso. Ele apenas adiciona o elemento de preenchimento.

    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

Tirou de uma aula. Apenas tire self, se você estiver trabalhando em um script autônomo.

Use a função format () integrada e a função int (). É simples e fácil de entender. É uma versão um pouco simplificada da resposta de Aaron

int ()

int(string, base)

formato()

format(integer, # of bits)

Exemplo

# 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

Veja também esta resposta

Substitua cada dígito hexadecimal pelos 4 dígitos binários correspondentes:

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

hexadecimal -> decimal e depois decimal -> binário

#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))

Outra maneira:

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')

Acrescentei o cálculo do número de bits a preencher à solução de Onedinkenedi. Aqui está a função resultante:

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

Onde 16 é a base da qual você está convertendo (hexadecimal) e 4 é quantos bits você precisa para representar cada dígito, ou log da base 2 da escala.

 def conversion():
    e=raw_input("enter hexadecimal no.:")
    e1=("a","b","c","d","e","f")
    e2=(10,11,12,13,14,15)
    e3=1
    e4=len(e)
    e5=()
    while e3<=e4:
        e5=e5+(e[e3-1],)
        e3=e3+1
    print e5
    e6=1
    e8=()
    while e6<=e4:
        e7=e5[e6-1]
        if e7=="A":
            e7=10
        if e7=="B":
            e7=11
        if e7=="C":
            e7=12
        if e7=="D":
            e7=13
        if e7=="E":
            e7=14
        if e7=="F":
            e7=15
        else:
            e7=int(e7)
        e8=e8+(e7,)
        e6=e6+1
    print e8

    e9=1
    e10=len(e8)
    e11=()
    while e9<=e10:
        e12=e8[e9-1]
        a1=e12
        a2=()
        a3=1 
        while a3<=1:
            a4=a1%2
            a2=a2+(a4,)
            a1=a1/2
            if a1<2:
                if a1==1:
                    a2=a2+(1,)
                if a1==0:
                    a2=a2+(0,)
                a3=a3+1
        a5=len(a2)
        a6=1
        a7=""
        a56=a5
        while a6<=a5:
            a7=a7+str(a2[a56-1])
            a6=a6+1
            a56=a56-1
        if a5<=3:
            if a5==1:
                a8="000"
                a7=a8+a7
            if a5==2:
                a8="00"
                a7=a8+a7
            if a5==3:
                a8="0"
                a7=a8+a7
        else:
            a7=a7
        print a7,
        e9=e9+1

eu tenho uma pequena esperança que ajude :-)

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)

primeiro eu uso sua entrada e enumero para obter cada símbolo. então eu converto para binário e apareço da 3ª posição até o final. O truque para obter o 0 é adicionar o valor máximo da entrada -> neste caso, sempre 16 :-)

a forma abreviada é o método de junção. Aproveitar.

# Python Program - Convert Hexadecimal to Binary
hexdec = input("Enter Hexadecimal string: ")
print(hexdec," in Binary = ", end="")    # end is by default "\n" which prints a new line
for _hex in hexdec:
    dec = int(_hex, 16)    # 16 means base-16 wich is hexadecimal
    print(bin(dec)[2:].rjust(4,"0"), end="")    # the [2:] skips 0b, and the 

A versão binária de ABC123EFFF é na verdade 1010101111000001001000111110111111111111

Para quase todos os aplicativos, você deseja que a versão binária tenha um comprimento múltiplo de 4 com preenchimento inicial de 0s.

Para obter isso em 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

Exemplo 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Exemplo 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Observe que isso também funciona no Micropython :)

Basta usar o código do módulo ^{(nota: eu sou o autor do módulo)}

Você pode converter haxedecimal em binário lá.

1. Instalar usando pip

pip install coden

2. Converter

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

As palavras-chave de conversão são:

• hex para hexadeimal
• bin para binário
• int para decimal
• _to_ - a palavra-chave de conversão para a função

Portanto, você também pode formatar: e. hexadecimal_output = 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

a = raw_input('hex number\n')
length = len(a)
ab = bin(int(a, 16))[2:]
while len(ab)<(length * 4):
    ab = '0' + ab
print ab

import binascii
hexa_input = input('Enter hex String to convert to Binary: ')
pad_bits=len(hexa_input)*4
Integer_output=int(hexa_input,16)
Binary_output= bin(Integer_output)[2:]. zfill(pad_bits)
print(Binary_output)
"""zfill(x) i.e. x no of 0 s to be padded left - Integers will overwrite 0 s
starting from right side but remaining 0 s will display till quantity x
[y:] where y is no of output chars which need to destroy starting from left"""

no=raw_input("Enter your number in hexa decimal :")
def convert(a):
    if a=="0":
        c="0000"
    elif a=="1":
        c="0001"
    elif a=="2":
        c="0010"
    elif a=="3":
        c="0011"
    elif a=="4":
        c="0100"
    elif a=="5":
        c="0101"
    elif a=="6":
        c="0110"
    elif a=="7":
        c="0111"
    elif a=="8":
        c="1000"
    elif a=="9":
        c="1001"
    elif a=="A":
        c="1010"
    elif a=="B":
        c="1011"
    elif a=="C":
        c="1100"
    elif a=="D":
        c="1101"
    elif a=="E":
        c="1110"
    elif a=="F":
        c="1111"
    else:
        c="invalid"
    return c

a=len(no)
b=0
l=""
while b<a:
    l=l+convert(no[b])
    b+=1
print l