it-swarm.com.de

Hex in Binär konvertieren

Ich habe ABC123EFFF.

Ich möchte 001010101111000001001000111110111111111111 haben (d. H. Binäre Repr. Mit 42 Ziffern und führenden Nullen).

Wie?

78

Um das Problem der linken Null mit der nachlaufenden Seite zu lösen:


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

89
Onedinkenedi
import binascii

binary_string = binascii.unhexlify(hex_string)

Lesen

binascii.unhexlify

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

51
rahul
bin(int("abc123efff", 16))[2:]
39
Glenn Maynard
>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

28
Simple

Hex in Binär konvertieren

Ich habe ABC123EFFF.

Ich möchte 001010101111000001001000111110111111111111 haben (d. H. Binär Repr. Mit 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 das mit der Semantik aufzulösen:

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

Lange Antwort:

Sie sagen eigentlich, dass Sie einen Wert in einer hexadezimalen Darstellung haben und einen äquivalenten Wert in binär darstellen möchten.

Der Äquivalenzwert ist eine ganze Zahl. Sie können jedoch mit einer Zeichenfolge beginnen, und um sie binär anzuzeigen, müssen Sie mit einer Zeichenfolge enden.

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

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

Bevor wir überhaupt binäre Manipulationen durchführen können, konvertieren Sie in int (ich nehme an, dass dies ein String-Format ist und kein Literal):

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

alternativ können wir ein Integer-Literal verwenden, das in hexadezimaler Form ausgedrückt wird:

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

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

Verwenden Sie die eingebaute Funktion format

Dann weiter zu format:

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

Dies verwendet die Formatierungsspezifikation mini-language

Um das aufzuschlüsseln, hier die Grammatikform:

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

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

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

und geben Sie das einfach an das Format weiter

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

String-Formatierung (Templating) mit str.format

Wir können das in einer Zeichenkette mit der str.format-Methode verwenden:

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

Oder fügen Sie einfach die Spezifikation direkt in den ursprünglichen String 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 Mini-Sprachformatierungsregeln:

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

Lassen Sie uns nun diese Funktion in eine Funktion integrieren, 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 Arbeitsspeicher oder auf der Festplatte kodieren möchten, können Sie die int.to_bytes-Methode 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, die durch 8 Bits pro Byte geteilt werden, 6 Byte entsprechen:

>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'
24
Aaron Hall
"{0:020b}".format(int('ABC123EFFF', 16))
13
Markus

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

Wobei entweder eine 0 oder eine 1 erzeugt wird, 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:

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

Würde werden:

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

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

9
John Montgomery

Dies ist eine leichte Änderung der Lösung von Glen Maynard, die meiner Meinung nach der richtige Weg ist. 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

Hat es aus einer Klasse gezogen. Nehmen Sie einfach self, heraus, wenn Sie mit einem eigenständigen Skript arbeiten.

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

'1010101111000001001000111110111111111111'

`bin(int("abc123efff", 16))[2:].zfill(50)`

'00000000001010101111000001001000111110111111111111'

(Die Nummer 50 sagt zfill, dass Sie die Zeichenfolge mit Nullen ergänzen möchten, bis die Zeichenfolgenlänge 50 lautet.)

4
Paulo

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

Ersetzen Sie jede Hex-Ziffer durch die entsprechenden 4 Binärstellen:

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

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')
1
ChristopheD
 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
0
Harshit Gupta

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

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

Wobei 16 die Basis ist, von der Sie konvertieren (hexadezimal), und 4 wie viele Bits Sie benötigen, um die einzelnen Ziffern oder die Protokollbasis 2 der Skala darzustellen.

0
Edd

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 liste sie auf, um jedes Symbol zu erhalten. dann konvertiere ich es in binär und trimme von der 3. Position bis zum Ende. Der Trick, um die 0 zu erhalten, ist den maximalen Wert der Eingabe hinzuzufügen -> in diesem Fall immer 16 :-) 

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

0
John