Convertir hexadecimal a binario

Tengo ABC123EFFF.

Quiero tener 001010101111000001001000111110111111111111 (es decir, repr. Binaria con, digamos, 42 dígitos y ceros iniciales).

¿Cómo?

Para resolver el problema del cero final del lado izquierdo:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Dará 00011010 en lugar de la versión recortada.

import binascii

binary_string = binascii.unhexlify(hex_string)

Leer

binascii.unhexlify

Devuelve los datos binarios representados por la cadena hexadecimal especificada como parámetro.

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

Convertir hexadecimal a binario

Tengo ABC123EFFF.

Quiero tener 001010101111000001001000111110111111111111 (es decir, repr. Binaria con, digamos, 42 dígitos y ceros iniciales).

Respuesta corta:

Las nuevas f-strings en Python 3.6 le permiten hacer esto usando una sintaxis muy concisa:

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

o romper eso con la semántica:

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

Respuesta larga:

Lo que en realidad está diciendo es que tiene un valor en una representación hexadecimal y quiere representar un valor equivalente en binario.

El valor de equivalencia es un número entero. Pero puede comenzar con una cadena y, para ver en binario, debe terminar con una cadena.

¿Convertir hexadecimal a binario, 42 dígitos y ceros a la izquierda?

Tenemos varias formas directas de lograr este objetivo, sin hacks que usan rodajas.

Primero, antes de que podamos hacer cualquier manipulación binaria, convierta a int (supongo que esto está en un formato de cadena, no como literal):

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

alternativamente, podríamos usar un literal entero como se expresa en forma hexadecimal:

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

Ahora necesitamos expresar nuestro número entero en una representación binaria.

Utilice la función incorporada, format

Luego pase a format:

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

Esto usa el mini-lenguaje de la especificación de formato. .

Para desglosar eso, aquí está la forma gramatical:

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

Para convertir eso en una especificación para nuestras necesidades, simplemente excluimos las cosas que no necesitamos:

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

y solo pasa eso para formatear

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

Formateo de cadenas (plantillas) con str.format

Podemos usar eso en una cadena usando el str.formatmétodo:

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

O simplemente coloque la especificación directamente en la cadena original:

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

Formateo de cadenas con las nuevas cadenas f

Demostremos las nuevas f-strings. Usan las mismas reglas de formato de mini-lenguaje:

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

Ahora pongamos esta funcionalidad en una función para fomentar la reutilización:

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

Y ahora:

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

Aparte

Si realmente solo desea codificar los datos como una cadena de bytes en la memoria o en el disco, puede usar el int.to_bytesmétodo, que solo está disponible en Python 3:

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

Y dado que 42 bits divididos por 8 bits por byte equivalen a 6 bytes:

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

Aquí hay una forma bastante cruda de hacerlo usando el violín de bits para generar las cadenas binarias.

La clave para entender es:

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

Lo que generará un 0 o un 1 si se establece el i-ésimo bit de 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

Editar: usando el operador ternario "nuevo" esto:

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

Se convertiría:

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

(Qué TBH, no estoy seguro de cuán legible es)

Este es un pequeño retoque a la solución de Glen Maynard, que creo que es la forma correcta de hacerlo. Simplemente agrega el elemento de relleno.

    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

Lo saqué de una clase. Solo sáquelo self, si está trabajando en un script independiente.

Utilice la función integrada format () y la función int () Es simple y fácil de entender. Es una versión un poco simplificada de la respuesta de Aaron

En t()

int(string, base)

formato()

format(integer, # of bits)

Ejemplo

# 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

Ver también esta respuesta

Reemplace cada dígito hexadecimal con los 4 dígitos binarios correspondientes:

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

hexadecimal -> decimal luego decimal -> binario

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

De otra manera:

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

Agregué el cálculo del número de bits a llenar a la solución de Onedinkenedi. Aquí está la función resultante:

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

Donde 16 es la base desde la que está convirtiendo (hexadecimal) y 4 es la cantidad de bits que necesita para representar cada dígito, o base logarítmica 2 de la 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

tengo una pequeña esperanza cortada que ayuda :-)

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)

primero utilizo su entrada y la enumero para obtener cada símbolo. luego lo convierto a binario y recorto desde la 3ª posición hasta el final. El truco para obtener el 0 es agregar el valor máximo de la entrada -> en este caso siempre 16 :-)

la forma corta es el método de unión. Disfrutar.

# 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 

La versión binaria de ABC123EFFF es en realidad 1010101111000001001000111110111111111111

Para casi todas las aplicaciones, desea que la versión binaria tenga una longitud que sea un múltiplo de 4 con un relleno inicial de 0.

Para obtener esto en 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

Ejemplo 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Ejemplo 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Tenga en cuenta que esto también funciona en Micropython :)

Simplemente use el módulo codificado ^{(nota: soy el autor del módulo)}

Puede convertir haxedecimal a binario allí.

1. Instalar usando pip

pip install coden

2. Convertir

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

Las palabras clave de conversión son:

• hexadecimal para hexadeimal
• bin para binario
• int para decimal
• _to_ - la palabra clave de conversión para la función

Entonces también puede formatear: e. salida_hexadecimal = bin_to_hex (un_número_binario)

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