Konvertieren Zahl in einen Binär-string

Ist dies der beste Weg zu konvertieren eine Python-Zahl in eine hex-string?

number = 123456789
hex(number)[2:-1].decode('hex')

Manchmal funktioniert es nicht und beschwert sich über die Seltsame Zeichenfolge mit der Länge, wenn Sie tun 1234567890.

Klarstellung:

Werde ich von int nach hex.

Auch, muss ich es escapen.

IE:
1234567890 -> '\x49\x96\x02\xd2' nicht '499602D2'

Auch, es muss in der Lage sein, Python-Ganzzahl. DH. etwas größer als ein Int.

Edit:

Hier ist die beste Lösung bisher habe ich zusammengeschustert von Paolo und Devin ' s post.

def hexify(num):
    num = "%x" % num

    if len(num) % 2:
        num = '0'+num

    return num.decode('hex')

Sie nicht möchten, konvertieren Sie Ihre Zahl in ein hex-string überhaupt; Sie möchten, konvertieren Sie ihn in eine binäre Darstellung, oder base256.
ack, "hex-string" ist wirklich nicht der richtige Begriff hier

InformationsquelleAutor Unknown | 2009-03-30

6

Können Sie string-Formatierung:
```
>>> number = 123456789
>>> hex = "%X" % number
>>> hex
'75BCD15'
```
- Ah schön, jetzt, wie bekomme ich es so ausgegeben wird '\x75\xbc\d1\x05'?
- Sie können verwenden Sie den Kleinbuchstaben "x", um es anzuzeigen, in Kleinbuchstaben, ich bin mir nicht sicher über den anderen Teil...
- Gut hex(Zahl)[2:-1].decode('hex') tut, außer es beeinträchtigt manchmal.
- Ich bin mir ziemlich sicher, dass Sie bedeuten [2:], nicht [2:-1] — den letztere schneidet die Letzte Ziffer.
- Ben: Oh ja, das ist ein anderes problem, manchmal hex() steckt ein 'L' am Ende.
- Hoffentlich gefällt Euch meine Antwort, die nicht mit hex() und so nicht das problem habe. 🙂
InformationsquelleAutor Paolo Bergantino
5

Ich bin mir nicht sicher, genau das, was Sie wollen, aber haben Sie schaute auf die struct Modul?

Gegeben
```
>>> hex(123456789)
'0x75bcd15'
```
Können Sie tun:
```
>>> struct.pack('i', 123456789)
'\x15\xcd[\x07'
```
Beachten Sie, dass '\x5b' == '['.

Können, können Sie auch in umgekehrter endianness:
```
>>> struct.pack('>i', 123456789)
'\x07[\xcd\x15'
```
Edit: ich bin mir nicht sicher, was du meinst mit "größer, als eine lange", da AFAIK longs in python sind unbegrenzt (außer durch Speicher). Jedoch, Sie können deal mit größeren ganzen zahlen nur durch die Aufteilung und Verkettung. z.B. gegeben:
```
>>> n = 123456789012345678901234567890
```
Ziel ist:
```
>>> hex(n)
'0x18ee90ff6c373e0ee4e3f0ad2L'
```
Also:
```
>>> s = ''
>>> while n >= 2**32:
...  n, r = divmod(n, 2**32)
...  s = struct.pack('>l', r) + s
... 
>>> s = struct.pack('>l', n) + s
```
Sehen, dass s entspricht das Ergebnis hex(n) oben:
```
>>> s
'\x00\x00\x00\x01\x8e\xe9\x0f\xf6\xc3s\xe0\xeeN?\n\xd2'
```
- Ich brauche etwas, das kann eine Zahl größer als ein Int oder long.
InformationsquelleAutor John Fouhy
1

Manchmal funktioniert es nicht und beschwert sich über die Seltsame Zeichenfolge mit der Länge, wenn Sie tun 1234567890.

Weil es nicht sinnvoll ist. Wie machen Sie fit 'AAB' in einem Raum, der nimmt entweder 2 oder 4 stellen? Jedes byte werden zwei hex-Zeichen. Wenn Sie eine ungerade Anzahl von hex-Zeichen, das gewünschte Ergebnis ist nicht eindeutig. Wollen Sie es auf den Gegenwert von 0AAB oder AAB0? Wenn Sie wissen, welche Sie wollen, es zu sein, entspricht, fügen Sie einfach, dass der Charakter an der richtigen Stelle, bevor die Decodierung.

d.h. (('0' + foo) if len(foo) % 2 else foo).decode('hex') wobei foo ein string der form zurückgegeben %x.
- Falsche Weg. Ich bin versucht zu gehen von int zu hex, nicht hex zu int.
- Sorry, das ich falsch verstanden und täuschte Zeug. Die Antwort ist jetzt geändert.
- (Zu mir) macht es mehr Sinn, fügen Sie eine führende 0 ein. Siehe meine Antwort. Der code kann leicht angepasst werden, wenn ein Leerzeichen ist bevorzugt.
- Deins beantwortet nicht seine Frage, entweder, obwohl. Es ergibt '\\x0F' anstelle von '\x0F'. Die wirkliche Antwort ist ein Einzeiler-- (('0' + foo) if len(foo) % 2 else foo).decode('hex')
- Ich (falsch?) angenommen, er will einen literalen backslash anstelle des tatsächlichen hex-Wert in der Zeichenfolge.
- Wer weiß. Ich habe es aufgegeben, auf diese Frage sowieso.
InformationsquelleAutor Devin Jeanpierre
1
```
'{0:b}'.format( number )
```
finden http://docs.python.org/library/string.html

InformationsquelleAutor Saw-mon and Natalie
0

Wenn Sie wissen, wie lange Sie Ihre Ausgabe-strings sein sollte, string-Formatierung arbeiten. Zum Beispiel, um vier-Zeichen-strings, benötigen Sie eine formatierte Länge von acht:
```
>>> "{0:08x}".format(123456789).decode("hex")
'\x07[\xcd\x15'
>>> "{0:08x}".format(1234567890).decode("hex")
'I\x96\x02\xd2'
```
Diese voran Nullen falls deine Nummer nicht "tanken" Sie die Zeichenfolge. Zum Beispiel, mit sechs-Zeichen-strings:
```
>>> "{0:012x}".format(123456789).decode("hex")
'\x00\x00\x07[\xcd\x15'
>>> "{0:012x}".format(1234567890).decode("hex")
'\x00\x00I\x96\x02\xd2'
```
Edit:

Zu "erkennen" Sie die Länge des Ziel-strings verwenden, können Sie die math.log Funktion:
```
>>> def int2str(n):
        l = int(math.ceil(math.log(n, 256) / 2) * 4)
        return ("{0:0{1}x}").format(n, l).decode("hex")

>>> int2str(123456789)
'\x07[\xcd\x15'
>>> int2str(1234567890)
'I\x96\x02\xd2'
```
- Gibt es eine Möglichkeit, automatisch erkennen die Länge, basierend auf der Größe der Zahl?
- es heißt Logarithmus
InformationsquelleAutor Ben Blank
0

Als Paolo erwähnt, string-Formatierung ist der Weg zu gehen. Beachten Sie, dass Sie können wählen zwischen klein-und Großbuchstaben:
```
>>> hex = lambda n: '%X' % n
>>> hex(42)
'2A'
>>> hex = lambda n: '%x' % n
>>> hex(42)
'2a'
>>> def escaped(n):
...     s = hex(n)
...     if len(s) & 1:
...          s = '0' + s
...     return ''.join(chr(int(s[i:i + 2], 16)) for i in range(0, len(s), 2))
...
>>> escaped(123)
'{'
>>> escaped(1234)
'\x04\xd2'
>>> escaped(12348767655764764654764445473245874398787989879879873)
'!\x01^\xa4\xdf\xdd(l\x9c\x00\\\xfa*\xf3\xb4\xc4\x94\x98\xa9\x03x\xc1'
```
Beachten Sie, dass entgangen fügt eine führende null im Fall einer ungerade Anzahl von hex-Ziffern. Diese Lösung funktioniert für strings beliebiger Länge.
- Ja, ich weiß, aber ich muss es umwandeln '\x2a' nicht '2a'
- Danke für den input. Es ist fast das gleiche wie das snippet habe ich gerade gemacht, aber ich wollte es nicht zu entkommen, so dass ich denke, es müsste schon ein char() anstelle von ".join('\\x")
- Okay, ich habe die return-Anweisung.
InformationsquelleAutor Stephan202

einer der sicherste Weg, für willkürliche zahlen, ist die Verwendung der 'array' - Modul so:

from array import array
binArr = array('B')

while(data):
    d = data & 0xFF
    binArr.append(d)
    data >>= 8

hexStr = binArr.tostring()

InformationsquelleAutor Vishal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.