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

Wie?

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.

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.

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

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'

>>> bin( 0xABC123EFFF )

'0b10101011110000010010001111101111111111'

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

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)

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.

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

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

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

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

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

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.

 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

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.

# 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 

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

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

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

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