Konwertuj szesnastkowy na binarny

107

Mam ABC123EFFF.

Chcę mieć 001010101111000001001000111110111111111111 (tj. Binarny odpowiednik z, powiedzmy, 42 cyframi i wiodącymi zerami).

W jaki sposób?

Aaron Hall
źródło

Odpowiedzi:

106

Aby rozwiązać lewostronny problem z końcowym zerem:


my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Da 00011010 zamiast wersji przyciętej.

Onedinkenedi
źródło
4
Obliczenie liczby bitów to len(my_hexdata) * log2(scale).
Edd
4
Nie zawiera zer wiodących, jeśli ciąg szesnastkowy zaczyna się od 00.
Dragon
@Dragon myhex = '1A' bin (int (myhex, 16)) [2:]. Zfill (8) >>> '00011010' zhex = '00' bin (int (zhex, 16)) [2:]. zfill (8) >>> '00000000' Wygląda na to, że działa to nawet wtedy, gdy ciągiem szesnastkowym jest „00”.
DeanM
59
import binascii

binary_string = binascii.unhexlify(hex_string)

Czytać

binascii.unhexlify

Zwraca dane binarne reprezentowane przez ciąg szesnastkowy określony jako parametr.

rahul
źródło
17
Zwraca wartość „binarną”, jak w rzeczywistych bajtach, ale nie konwertuje jej na reprezentację drukowalną jako „0” i „1”.
Matt Good,
Docs.python.org/library/binascii.html ma napisy Konwersja między binarnymi a ASCII. Czy to nie oznacza, że ​​zwraca ciąg?
pavium
Tak, zwraca ciąg zawierający reprezentowane bajty, np. >>> unhexlify ("ab") "\ xab"
Matt Good,
9
Masz jakiś pomysł, jak zwrócić „001010100”?
David 天宇 Wong
1
Nie wiem, dlaczego głosowano w tym głosowaniu, ponieważ nie odpowiada faktycznej prośbie OP - zobacz inne posty, aby uzyskać odpowiedź
David Glance
45
bin(int("abc123efff", 16))[2:]
Glenn Maynard
źródło
7
Jeśli wartość wejściowa to „1a”, daje to „11010”, a nie „00011010”, co może, ale nie musi, być tym, czego chcesz.
Matt Good,
4
Jest całkiem rozsądne, aby potrzebować wiodących zer (i ich nie potrzebować). Możesz na przykład chcieć, aby bajt zerowy 0x00 miał osiem bitów zerowych - jest to ważne dla niektórych aplikacji. Również OP ma w swoim przykładzie wiodące zero (ale podejrzewam, że w tym przypadku jest to po prostu przypadkowe!)
Scott Griffiths
42

Konwertuj szesnastkowy na binarny

Mam ABC123EFFF.

Chcę mieć 001010101111000001001000111110111111111111 (tj. Binarny odpowiednik z, powiedzmy, 42 cyframi i wiodącymi zerami).

Krótka odpowiedź:

Nowe f-stringi w Pythonie 3.6 pozwalają na to przy użyciu bardzo zwięzłej składni:

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

albo żeby zerwać z semantyką:

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

Długa odpowiedź:

W rzeczywistości mówisz, że masz wartość w reprezentacji szesnastkowej i chcesz przedstawić równoważną wartość w postaci binarnej.

Wartość równoważności jest liczbą całkowitą. Ale możesz zacząć od ciągu znaków, a aby wyświetlić dane binarne, musisz zakończyć ciągiem.

Konwertować szesnastkowe na binarne, 42 cyfry i wiodące zera?

Mamy kilka bezpośrednich sposobów osiągnięcia tego celu, bez hacków przy użyciu plasterków.

Po pierwsze, zanim w ogóle będziemy mogli wykonać jakąkolwiek operację binarną, przekonwertuj na int (zakładam, że jest to w formacie ciągu, a nie jako literał):

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

alternatywnie możemy użyć literału całkowitego wyrażonego w postaci szesnastkowej:

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

Teraz musimy wyrazić naszą liczbę całkowitą w postaci binarnej.

Użyj funkcji wbudowanej, format

Następnie przejdź do format:

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

Używa mini-języka specyfikacji formatowania .

Aby to wyjaśnić, oto forma gramatyczna:

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

Aby uczynić to specyfikacją dla naszych potrzeb, po prostu wykluczamy rzeczy, których nie potrzebujemy:

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

i po prostu przekaż to do formatu

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

Formatowanie ciągów (tworzenie szablonów) za pomocą str.format

Możemy tego użyć w łańcuchu za pomocą str.formatmetody:

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

Lub po prostu umieść specyfikację bezpośrednio w oryginalnym ciągu:

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

Formatowanie ciągów za pomocą nowych f-stringów

Pokażmy nowe struny F. Używają tych samych reguł formatowania w minijęzykach:

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

Teraz umieśćmy tę funkcjonalność w funkcji zachęcającej do ponownego użycia:

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

I teraz:

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

Na bok

Jeśli faktycznie chciałeś zakodować dane jako ciąg bajtów w pamięci lub na dysku, możesz użyć int.to_bytesmetody, która jest dostępna tylko w Pythonie 3:

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

A ponieważ 42 bity podzielone przez 8 bitów na bajt to 6 bajtów:

>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'
Aaron Hall
źródło
31
>>> bin( 0xABC123EFFF )

„0b1010101111000001001000111110111111111111”

Prosty
źródło
2
Nie zawiera zer wiodących, jeśli ciąg szesnastkowy zaczyna się od 00.
Dragon
14
"{0:020b}".format(int('ABC123EFFF', 16))
Markus
źródło
3
Nie zawiera zer wiodących, jeśli ciąg szesnastkowy zaczyna się od 00.
Dragon
10

Oto dość surowy sposób na zrobienie tego za pomocą bitowego manipulowania przy generowaniu ciągów binarnych.

Kluczową kwestią do zrozumienia jest:

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

Co wygeneruje 0 lub 1, jeśli ustawiony jest i-ty bit 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

Edytuj: używając „nowego” operatora trójskładnikowego:

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

Stanie się:

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

(Który TBH nie jestem pewien, jak to jest czytelne)

John Montgomery
źródło
1
Wiem, że to jest stare, ale jaki dokładnie jest sens „i 1”?
Goodies
To za dawne czasy Pythona przed operatorem trójskładnikowym. (N & (1 << i)) zwróci zero lub coś innego niż zero. Chcemy tylko jedynki lub zera, więc „i 1” są w stanie to zapewnić.
John Montgomery,
Ten skrypt działał najlepiej dla mnie do konwersji klucza prywatnego kryptograficznego w formacie szesnastkowym na binarny do celów testowych. Czy ktoś wie, jak podzielić ciąg binarny na 8-bitowe fragmenty i wydrukować? tj 01111001 11111110.
Edison,
5

To drobny akcent do rozwiązania Glena Maynarda, który moim zdaniem jest właściwym sposobem. Po prostu dodaje element wypełniający.


    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

Wyciągnąłem to z klasy. Po prostu wyjmij, self, jeśli pracujesz w samodzielnym skrypcie.

RobotHumans
źródło
5

Użyj wbudowanej funkcji format () i funkcji int () Jest to proste i łatwe do zrozumienia. To trochę uproszczona wersja odpowiedzi Aarona

int ()

int(string, base)

format()

format(integer, # of bits)

Przykład

# 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

Zobacz także tę odpowiedź

nikt
źródło
3

Zastąp każdą cyfrę szesnastkową odpowiednimi 4 cyframi binarnymi:

1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
DmitryK
źródło
2
Lub zamień każdą parę cyfr szesnastkowych na odpowiadające im 8 cyfr binarnych lub zamień każdą trojkę cyfr szesnastkowych na odpowiednie 12 cyfr binarnych ... lub zamień każde 10 cyfr szesnastkowych na odpowiednie 40 cyfr binarnych - Ups! tam gdzie zaczęliśmy!
pavium
2

szesnastkowe -> dziesiętne, a następnie dziesiętne -> dwójkowe

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

źródło
1

Inny sposób:

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
źródło
Nie powiedzie się, jeśli hex_string jest ustawiony na 'f0'
mikemaccana
1

Dodałem obliczenie liczby bitów do wypełnienia do rozwiązania Onedinkenedi. Oto wynikowa funkcja:

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

Gdzie 16 to podstawa, z której konwertujesz (szesnastkowo), a 4 to liczba bitów potrzebnych do przedstawienia każdej cyfry lub podstawy logu 2 skali.

Edd
źródło
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
źródło
0

mam krótką nadzieję, która pomaga :-)

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)

najpierw używam twoich danych wejściowych i wyliczam je, aby uzyskać każdy symbol. następnie konwertuję go na binarny i przycinam od 3 pozycji do końca. Sztuczka, aby uzyskać 0, polega na dodaniu maksymalnej wartości wejścia -> w tym przypadku zawsze 16 :-)

krótką formą jest metoda łączenia. Cieszyć się.

Jan
źródło
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
źródło
0

Binarna wersja ABC123EFFF to w rzeczywistości 1010101111000001001000111110111111111111

Dla prawie wszystkich aplikacji chcesz, aby wersja binarna miała długość będącą wielokrotnością 4 z początkowym dopełnieniem równym 0.

Aby uzyskać to w Pythonie:

def hex_to_binary( hex_code ):
  bin_code = bin( hex_code )[2:]
  padding = (4-len(bin_code)%4)%4
  return '0'*padding + bin_code

Przykład 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Przykład 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Zauważ, że działa to również w Micropython :)

Stefan
źródło
0

Po prostu użyj kodu modułu (uwaga: jestem autorem modułu)

Możesz tam przekonwertować szesnastkowy na dwójkowy.

  1. Zainstaluj za pomocą pip
pip install coden
  1. Konwertować
a_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)

Konwertujące słowa kluczowe to:

  • hex dla szesnastkowego
  • bin dla plików binarnych
  • int dla dziesiętnych
  • _to_ - słowo kluczowe konwertujące dla funkcji

Możesz więc również sformatować: e. hexadecimal_output = bin_to_hex (a_binary_number)

matematyka
źródło
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
źródło
-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
źródło
7
Gdzie jest opis / wyjaśnienie?
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
źródło
-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
warunn
źródło