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?
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.
import binascii
binary_string = binascii.unhexlify(hex_string)
Lesen
Gibt die Binärdaten zurück, die durch die als Parameter angegebene Hexadezimalzeichenfolge dargestellt werden.
bin(int("abc123efff", 16))[2:]
>>> bin( 0xABC123EFFF )
'0b1010101111000001001000111110111111111111'
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'
"{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 1Wobei 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 1Würde werden:
1 if n & (1 << i) or 0(Welche TBH ich bin nicht sicher, wie lesbar das ist)
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.
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.)
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))
Ersetzen Sie jede Hex-Ziffer durch die entsprechenden 4 Binärstellen:
1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
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')
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 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.
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.