Converter hex para binário

106

Eu tenho ABC123EFFF.

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

Quão?

Aaron Hall
fonte

Respostas:

106

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.

Onedinkenedi
fonte
4
O cálculo do número de bits é len(my_hexdata) * log2(scale).
Edd
4
Não fornece zeros à esquerda se a string hexadecimal começar com 00.
Dragon
@Dragon myhex = '1A' bin (int (myhex, 16)) [2:]. Zfill (8) >>> '00011010' zhex = '00' bin (int (zhex, 16)) [2:]. zfill (8) >>> '00000000' Parece que funciona mesmo quando a string hexadecimal é '00'.
DeanM de
58
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.

Rahul
fonte
17
Isso retorna "binário" como nos bytes reais, mas não o converte em uma representação imprimível como "0" e "1".
Matt Good,
docs.python.org/library/binascii.html é legendado como Converter entre binário e ASCII. Isso não significa que retorna uma string?
pavium de
Sim, ele retorna uma string contendo os bytes representados, por exemplo, >>> unhexlify ("ab") "\ xab"
Matt Good
9
Alguma ideia de como retornar "001010100"?
David 天宇 Wong
1
Não sei por que isso foi votado, já que não atende ao pedido real do OP - veja qualquer uma das outras postagens para obter uma resposta
David Glance
45
bin(int("abc123efff", 16))[2:]
Glenn Maynard
fonte
7
Se a entrada for "1a", isso dará "11010", não "00011010", que pode ser ou não o que você deseja.
Matt Good,
4
É bastante razoável precisar dos zeros à esquerda (e não precisar deles). Você pode querer que o byte nulo 0x00 tenha oito bits zero, por exemplo - isso é importante para alguns aplicativos. Além disso, o OP tem um zero à esquerda em seu exemplo (mas eu suspeito que isso seja apenas aleatório neste caso!)
Scott Griffiths,
42

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'
Aaron Hall
fonte
31
>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

Simples
fonte
2
Não fornece zeros à esquerda se a string hexadecimal começar com 00.
Dragon
14
"{0:020b}".format(int('ABC123EFFF', 16))
Markus
fonte
3
Não fornece zeros à esquerda se a string hexadecimal começar com 00.
Dragon
10

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)

John Montgomery
fonte
1
Eu sei que isso é antigo, mas qual é exatamente o ponto do "e 1"?
Goodies
É para os velhos tempos do python, antes do operador ternário. O (n & (1 << i)) retornará zero ou algo diferente de zero. Queremos apenas um ou zero, para que "e 1" existam para garantir isso.
John Montgomery
Este script funcionou melhor para mim converter uma chave privada criptográfica em hexadecimal para binário para fins de teste. Alguém sabe como dividir a string binária em pedaços de 8 bits e imprimi-la? ie 01111001 11111110.
Edison
5

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.

RobotHumans
fonte
5

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

ninguém
fonte
3

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

1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
DmitryK
fonte
2
Ou substitua cada par de dígitos hexadecimais com os 8 dígitos binários correspondentes, ou substitua cada tripleto de dígitos hexadecimais com os 12 dígitos binários correspondentes ... ou substitua cada 10 dígitos hexadecimais, com os 40 dígitos binários correspondentes - Ops! de volta onde começamos!
pavium de
2

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

fonte
1

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')
ChristopheD
fonte
Falha se hex_string estiver definido como 'f0'
mikemaccana
1

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.

Edd
fonte
0
 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
Harshit Gupta
fonte
0

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.

John
fonte
0
# 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 
moe assal
fonte
0

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

Stefan
fonte
0

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

matemática
fonte
0

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
Yilmaz
fonte
-1
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
Ashwini
fonte
7
Onde está a descrição / explicação?
Sufian
-1
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"""
khattanemu
fonte
-7
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
avisar
fonte