Converti esadecimale in binario

Ho ABC123EFFF.

Voglio avere 001010101111000001001000111110111111111111 (cioè una riproduzione binaria con, diciamo, 42 cifre e zeri iniziali).

Come?

Per risolvere il problema dello zero finale sul lato sinistro:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Darà 00011010 invece della versione tagliata.

import binascii

binary_string = binascii.unhexlify(hex_string)

Leggere

binascii.unhexlify

Restituisce i dati binari rappresentati dalla stringa esadecimale specificata come parametro.

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

Converti esadecimale in binario

Ho ABC123EFFF.

Voglio avere 001010101111000001001000111110111111111111 (cioè una riproduzione binaria con, diciamo, 42 cifre e zeri iniziali).

Risposta breve:

Le nuove stringhe f in Python 3.6 ti consentono di farlo usando una sintassi molto concisa:

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

o per rompere con la semantica:

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

Risposta lunga:

Quello che stai effettivamente dicendo è che hai un valore in una rappresentazione esadecimale e vuoi rappresentare un valore equivalente in binario.

Il valore di equivalenza è un numero intero. Ma puoi iniziare con una stringa e, per visualizzare in binario, devi terminare con una stringa.

Converti esadecimale in binario, 42 cifre e zeri iniziali?

Abbiamo diversi modi diretti per raggiungere questo obiettivo, senza hack utilizzando le sezioni.

Innanzitutto, prima di poter eseguire qualsiasi manipolazione binaria, converti in int (presumo che sia in un formato stringa, non come letterale):

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

in alternativa potremmo usare un intero letterale espresso in forma esadecimale:

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

Ora dobbiamo esprimere il nostro numero intero in una rappresentazione binaria.

Usa la funzione incorporata, format

Quindi passare a format:

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

Utilizza il mini-linguaggio della specifica di formattazione .

Per scomporlo, ecco la forma grammaticale:

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

Per renderlo una specifica per le nostre esigenze, escludiamo semplicemente le cose di cui non abbiamo bisogno:

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

e passalo al formato

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

Formattazione delle stringhe (modelli) con str.format

Possiamo usarlo in una stringa usando il str.formatmetodo:

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

Oppure inserisci la specifica direttamente nella stringa originale:

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

String Formattazione con le nuove f-string

Dimostriamo le nuove stringhe f. Usano le stesse regole di formattazione del mini-linguaggio:

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

Ora inseriamo questa funzionalità in una funzione per incoraggiare la riusabilità:

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

E adesso:

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

A parte

Se in realtà volevi solo codificare i dati come una stringa di byte in memoria o su disco, puoi utilizzare il int.to_bytesmetodo, che è disponibile solo in Python 3:

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

E poiché 42 bit divisi per 8 bit per byte equivalgono a 6 byte:

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

Ecco un modo abbastanza grezzo per farlo usando un po 'di giocherellare per generare le stringhe binarie.

La parte fondamentale da capire è:

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

Che genererà uno 0 o 1 se è impostato l'i-esimo bit di 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

Modifica: utilizzando il "nuovo" operatore ternario questo:

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

Potrebbe diventare:

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

(Quale TBH non sono sicuro di quanto sia leggibile)

Questo è un leggero ritocco alla soluzione di Glen Maynard, che penso sia il modo giusto per farlo. Aggiunge solo l'elemento di imbottitura.

    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

L'ho tirato fuori da una classe. Basta tirare fuori self, se stai lavorando a uno script autonomo.

Usa la funzione incorporata format () e int () È semplice e facile da capire. È una versione leggermente semplificata della risposta di Aaron

int ()

int(string, base)

formato()

format(integer, # of bits)

Esempio

# 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

Vedi anche questa risposta

Sostituisci ogni cifra esadecimale con le 4 cifre binarie corrispondenti:

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

hex -> decimal then decimal -> binary

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

Un altro modo:

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

Ho aggiunto il calcolo del numero di bit da riempire alla soluzione di Onedinkenedi. Ecco la funzione risultante:

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

Dove 16 è la base da cui stai convertendo (esadecimale) e 4 è il numero di bit di cui hai bisogno per rappresentare ogni cifra o logaritmo in base 2 della scala.

 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

ho una breve speranza che aiuta :-)

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)

per prima cosa uso il tuo input e lo enumero per ottenere ogni simbolo. poi lo converto in binario e taglio dalla 3a posizione alla fine. Il trucco per ottenere lo 0 è aggiungere il valore massimo dell'input -> in questo caso sempre 16 :-)

la forma abbreviata è il metodo di join. Godere.

# 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 versione binaria di ABC123EFFF è in realtà 1010101111000001001000111110111111111111

Per quasi tutte le applicazioni si desidera che la versione binaria abbia una lunghezza multipla di 4 con spaziatura iniziale di 0.

Per ottenere questo in 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

Esempio 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Esempio 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Nota che funziona anche in Micropython :)

Usa semplicemente il codice del modulo ^{(nota: sono l'autore del modulo)}

Puoi convertire haxedecimal in binario lì.

1. Installa usando pip

pip install coden

2. Convertire

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

Le parole chiave di conversione sono:

• hex per esadeimale
• bin per binario
• int per decimale
• _to_ - la parola chiave di conversione per la funzione

Quindi puoi anche formattare: 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