Convertir hexadecimal a binario

Tengo ABC123EFFF.

Quiero tener 001010101111000001001000111110111111111111 (es decir, reproducción binaria con, digamos, 42 dígitos y ceros iniciales).

¿Cómo?

Para resolver el problema del cero final 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:] 
 >>> bin( 0xABC123EFFF ) 

‘0b1010101111000001001000111110111111111111’

Convertir hexadecimal a binario

Tengo ABC123EFFF.

Quiero tener 001010101111000001001000111110111111111111 (es decir, reproducción binaria con, digamos, 42 dígitos y ceros iniciales).

Respuesta corta:

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

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

o para 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 realmente estás diciendo es que tienes un valor en una representación hexadecimal y quieres representar un valor equivalente en binario.

El valor de equivalencia es un 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 iniciales?

Tenemos varias formas directas de lograr este objective, sin trucos con cortes.

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

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

alternativamente, podríamos usar un literal entero expresado en forma hexadecimal:

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

Ahora necesitamos express nuestro entero en una representación binaria.

Utilice la función incorporada, format

Luego pasar al format :

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

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

Para descomponerlo, aquí está la forma gtwigtical de esto:

 [[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 

Formato de cadena (Plantilla) con str.format

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

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

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

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

Formato de cadenas con las nuevas cadenas f

Demostremos las nuevas cuerdas. Usan las mismas reglas de formato de mini-idioma:

 >>> 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 método int.to_bytes , que solo está disponible en Python 3:

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

Y como 42 bits divididos por 8 bits por byte es igual a 6 bytes:

 >>> integer.to_bytes(6, 'big') b'\x00\xab\xc1#\xef\xff' 
 "{0:020b}".format(int('ABC123EFFF', 16)) 

Aquí hay una manera bastante simple de hacerlo utilizando 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 bit i 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 

Edición: usando el "nuevo" operador ternario esto:

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

Se convertiría:

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

(Que TBH no estoy seguro de lo legible que es)

Este es un pequeño toque para 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 sacó de una clase. Solo self, si está trabajando en un script independiente.

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

 `bin(int("abc123efff", 16))[2:].zfill(50)` '00000000001010101111000001001000111110111111111111' 

(El número 50 le dirá a zfill que desea completar la cadena con ceros hasta que la longitud de la cadena sea 50 ).

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

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

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

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 para el número de bits que se deben 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ás convirtiendo (hexadecimal), y 4 es la cantidad de bits que necesitas para representar cada dígito, o registrar la base 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 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 uso su entrada y la enumero para obtener cada símbolo. luego lo convierto a binario y recorte 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.

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