Wandle Hex in Binär um

105

Ich habe ABC123EFFF.

Ich möchte 001010101111000001001000111110111111111111 haben (dh binäre Repräsentation mit beispielsweise 42 Ziffern und führenden Nullen).

Wie?

Aaron Hall
quelle

Antworten:

106

Zur Lösung des Problems der nachgestellten Null auf der linken Seite:


my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Es wird 00011010 anstelle der getrimmten Version geben.

Onedinkenedi
quelle
4
Berechnung für die Anzahl der Bits ist len(my_hexdata) * log2(scale).
Edd
4
Liefert keine führenden Nullen, wenn die Hex-Zeichenfolge mit 00 beginnt.
Dragon
@Dragon myhex = '1A' bin (int (myhex, 16)) [2:]. Zfill (8) >>> '00011010' zhex = '00' bin (int (zhex, 16)) [2:]. zfill (8) >>> '00000000' Es scheint, dass dies auch dann funktioniert, wenn die Hex-Zeichenfolge '00' ist.
DeanM
58
import binascii

binary_string = binascii.unhexlify(hex_string)

Lesen

binascii.unhexlify

Gibt die Binärdaten zurück, die durch die als Parameter angegebene hexadezimale Zeichenfolge dargestellt werden.

rahul
quelle
17
Dies gibt "binär" wie in den tatsächlichen Bytes zurück, konvertiert es jedoch nicht in eine druckbare Darstellung als "0" und "1".
Matt Good
docs.python.org/library/binascii.html hat den Untertitel Konvertieren zwischen Binär und ASCII. Bedeutet das nicht, dass eine Zeichenfolge zurückgegeben wird?
Pavium
Ja, es wird eine Zeichenfolge zurückgegeben, die die dargestellten Bytes enthält, z. B. >>> unhexlify ("ab") "\ xab"
Matt Good
9
Irgendeine Idee, wie man "001010100" zurückgibt?
David 天宇 Wong
1
Ich weiß nicht, warum dies abgelehnt wurde, da es die tatsächliche Anfrage des OP nicht beantwortet - siehe einen der anderen Beiträge für eine Antwort
David Glance
45
bin(int("abc123efff", 16))[2:]
Glenn Maynard
quelle
7
Wenn die Eingabe "1a" ist, ergibt dies "11010", nicht "00011010", was möglicherweise das ist, was Sie wollen oder nicht.
Matt Good
4
Es ist durchaus vernünftig, die führenden Nullen zu benötigen (und sie nicht zu benötigen). Möglicherweise möchten Sie, dass das Nullbyte 0x00 beispielsweise acht Nullbits enthält. Dies ist für einige Anwendungen wichtig. Auch der OP hat eine führende Null in seinem Beispiel (aber ich vermute, dass das in diesem Fall nur zufällig ist!)
Scott Griffiths
42

Wandle Hex in Binär um

Ich habe ABC123EFFF.

Ich möchte 001010101111000001001000111110111111111111 haben (dh binäre Repräsentation mit beispielsweise 42 Ziffern und führenden Nullen).

Kurze Antwort:

Mit den neuen F-Strings in Python 3.6 können Sie dies mit einer sehr knappen Syntax tun:

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

oder um das mit der Semantik zu brechen:

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

Lange Antwort:

Was Sie tatsächlich sagen, ist, dass Sie einen Wert in einer hexadezimalen Darstellung haben und einen äquivalenten Wert in einer Binärdarstellung darstellen möchten.

Der Wert der Äquivalenz ist eine ganze Zahl. Sie können jedoch mit einer Zeichenfolge beginnen. Um eine Binärdatei anzuzeigen, müssen Sie mit einer Zeichenfolge enden.

Hex in Binär, 42 Ziffern und führende Nullen umwandeln?

Wir haben mehrere direkte Möglichkeiten, um dieses Ziel zu erreichen, ohne Hacks mit Slices.

Bevor wir überhaupt eine binäre Manipulation durchführen können, konvertieren Sie zunächst in int (ich nehme an, dass dies in einem Zeichenfolgenformat und nicht als Literal erfolgt):

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

alternativ könnten wir ein ganzzahliges Literal verwenden, das in hexadezimaler Form ausgedrückt wird:

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

Jetzt müssen wir unsere ganze Zahl in einer binären Darstellung ausdrücken.

Verwenden Sie die eingebaute Funktion, format

Dann weitergeben an format:

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

Diese verwendet die Formatierung der Spezifikation Mini-Sprache .

Um das aufzuschlüsseln, hier ist die Grammatikform:

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

Um dies zu einer Spezifikation für unsere Bedürfnisse zu machen, schließen wir nur die Dinge aus, die wir nicht brauchen:

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

und übergeben Sie das einfach an das Format

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

String-Formatierung (Template) mit str.format

Wir können das in einem String mit der str.formatMethode verwenden:

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

Oder fügen Sie die Spezifikation einfach direkt in die ursprüngliche Zeichenfolge ein:

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

String-Formatierung mit den neuen F-Strings

Lassen Sie uns die neuen F-Strings demonstrieren. Sie verwenden dieselben Formatierungsregeln für Mini-Sprachen:

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

Fügen wir diese Funktionalität nun in eine Funktion ein, um die Wiederverwendbarkeit zu fördern:

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

Und nun:

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

Beiseite

Wenn Sie die Daten eigentlich nur als Byte-Zeichenfolge im Speicher oder auf der Festplatte codieren möchten, können Sie die int.to_bytesMethode verwenden, die nur in Python 3 verfügbar ist:

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

Und da 42 Bits geteilt durch 8 Bits pro Byte 6 Bytes entsprechen:

>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'
Aaron Hall
quelle
31
>>> bin( 0xABC123EFFF )

'0b10101011110000010010001111101111111111'

Einfach
quelle
2
Liefert keine führenden Nullen, wenn die Hex-Zeichenfolge mit 00 beginnt.
Dragon
14
"{0:020b}".format(int('ABC123EFFF', 16))
Markus
quelle
3
Liefert keine führenden Nullen, wenn die Hex-Zeichenfolge mit 00 beginnt.
Dragon
10

Hier ist eine ziemlich rohe Methode, um die binären Zeichenfolgen mithilfe von Bit-Fiddling zu generieren.

Der Schlüssel zum Verständnis ist:

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

Dies erzeugt entweder eine 0 oder eine 1, wenn das i-te Bit von n gesetzt ist.


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

Bearbeiten: mit dem "neuen" ternären Operator dies:

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

Würde werden:

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

(Welche TBH bin ich mir nicht sicher, wie lesbar das ist)

John Montgomery
quelle
1
Ich weiß, dass dies alt ist, aber was genau ist der Sinn des "und 1"?
Goodies
Es ist für die alten Tage von Python vor dem ternären Operator. Das (n & (1 << i)) gibt entweder Null oder etwas anderes als Null zurück. Wir wollen nur eine Eins oder Null, damit "und 1" da ist, um das zu gewährleisten.
John Montgomery
Dieses Skript hat für mich am besten funktioniert, um einen privaten Kryptoschlüssel in Hex zu Testzwecken in Binär umzuwandeln. Weiß jemand, wie man die Binärzeichenfolge in 8-Bit-Blöcke aufteilt und ausdruckt? dh 01111001 11111110.
Edison
5

Dies ist eine kleine Verbesserung der Lösung von Glen Maynard, die meiner Meinung nach der richtige Weg ist, dies zu tun. Es wird nur das Auffüllelement hinzugefügt.


    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

Zog es aus einer Klasse. Nehmen self, Sie es einfach heraus, wenn Sie in einem eigenständigen Skript arbeiten.

RobotHumans
quelle
5

Verwenden Sie die integrierte Funktion format () und die Funktion int (). Sie ist einfach und leicht zu verstehen. Es ist eine etwas vereinfachte Version der Antwort von Aaron

int ()

int(string, base)

Format()

format(integer, # of bits)

Beispiel

# 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

Siehe auch diese Antwort

niemand
quelle
3

Ersetzen Sie jede hexadezimale Ziffer durch die entsprechenden 4 Binärziffern:

1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
DmitryK
quelle
2
Oder ersetzen Sie jedes Hex-Ziffernpaar durch die entsprechenden 8 Binärziffern oder ersetzen Sie jedes Triplett von Hexadezimalziffern durch die entsprechenden 12 Binärziffern ... oder ersetzen Sie jeweils 10 Hexadezimalziffern durch die entsprechenden 40 Binärziffern - Ups! zurück wo wir angefangen haben!
Pavium
2

hex -> dezimal dann dezimal -> binär

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

quelle
1

Ein anderer Weg:

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
quelle
Dies schlägt fehl, wenn hex_string auf 'f0' gesetzt ist
mikemaccana
1

Ich habe die Berechnung für die Anzahl der zu füllenden Bits zu Onedinkenedis Lösung hinzugefügt. Hier ist die resultierende Funktion:

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

Dabei ist 16 die Basis, von der Sie konvertieren (hexadezimal), und 4 die Anzahl der Bits, die Sie zur Darstellung jeder Ziffer oder der Protokollbasis 2 der Skala benötigen.

Edd
quelle
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
quelle
0

Ich habe eine kurze Hoffnung, die hilft :-)

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)

Zuerst benutze ich deine Eingabe und zähle sie auf, um jedes Symbol zu erhalten. dann konvertiere ich es in binär und schneide von der 3. Position bis zum Ende. Der Trick, um die 0 zu erhalten, besteht darin, den Maximalwert der Eingabe zu addieren -> in diesem Fall immer 16 :-)

Die Kurzform ist die Join-Methode. Genießen.

John
quelle
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
quelle
0

Die Binärversion von ABC123EFFF ist tatsächlich 1010101111000001001000111110111111111111

Für fast alle Anwendungen soll die Binärversion eine Länge haben, die ein Vielfaches von 4 mit einem führenden Abstand von 0 ist.

So erhalten Sie dies 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

Beispiel 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Beispiel 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Beachten Sie, dass dies auch in Micropython funktioniert :)

Stefan
quelle
0

Verwenden Sie einfach den Modul- Coden (Hinweis: Ich bin der Autor des Moduls)

Dort können Sie haxedecimal in binär konvertieren.

  1. Mit pip installieren
pip install coden
  1. Konvertieren
a_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)

Die konvertierenden Schlüsselwörter sind:

  • hex für hexadeimal
  • bin für binär
  • int für dezimal
  • _to_ - das konvertierende Schlüsselwort für die Funktion

Sie können also auch Folgendes formatieren: e. hexadecimal_output = bin_to_hex (a_binary_number)

Mathematik
quelle
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
quelle
-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
quelle
7
Wo ist die Beschreibung / Erklärung?
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
quelle
-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
quelle