Wydrukować ciąg jako bajty szesnastkowe?


155

Mam ten ciąg: Hello world !!i chcę go wydrukować za pomocą Pythona jako 48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21.

hex() działa tylko dla liczb całkowitych.

Jak można to zrobić?


Jeśli chodzi o zwrócenie tylko dwucyfrowych wartości szesnastkowych, to pytanie implikuje użycie ciągów bajtów (np. Python 2 strlub Python 3 bytestring), ponieważ nie ma jednoznacznej transformacji znaku w liczbę całkowitą w 0… 255. Dlatego ciągi znaków (Python 2 unicodei Python 3 str) wymagają najpierw pewnego kodowania, zanim zostaną przekonwertowane na ten format szesnastkowy. Odpowiedź Aarona Halla jest tego przykładem.
Eric O Lebigot

Odpowiedzi:


227

Możesz przekształcić swój ciąg w generator int, zastosować formatowanie szesnastkowe dla każdego elementu i interkalować z separatorem:

>>> s = "Hello world !!"
>>> ":".join("{:02x}".format(ord(c)) for c in s)
'48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21

3
Zwróć uwagę, że w pythonie3 koncepcja drukowania stras hex nie ma sensu; będziesz chciał wydrukować bytesobiekt jako hex (przekonwertować strna bytesprzez wywołanie .encode()).
mic_e

8
W rzeczywistości, to wytwarza nieprawidłowy wydatek python3: ":".join("{:02x}".format(ord(c)) for c in 'løl')powrotów '6c:f8:6c', podczas gdy ":".join("{:02x}".format(c) for c in 'løl'.encode())produkuje prawidłowy UTF-8 reprezentacji '6c:c3:b8:6c'.
mic_e

2
To pytanie i odpowiedź w pewnym sensie zakładają, że dane wejściowe nigdy nie zawierają znaków spoza zestawu ASCII. Jeśli wejście może zawierać rzeczy jak emotikony lub niełacińskie systemów opartych pisanie, może chcesz używać ":".join("{:04x}".format(ord(c)) for c in s)(zastępującego 02xz 04xzero-pad każdy numer będzie 4 cyfry), a nie
Borys

@mic_e Dlaczego to jest? Scapy odwołuje się do tego, gdy próbujesz go we wbudowanym tłumaczu. WARNING: Calling str(pkt) on Python 3 makes no sense!
sherrellbc

157
':'.join(x.encode('hex') for x in 'Hello World!')

3
Jak to zrobić w python3?
h__

6
@hyh: h = binascii.hexlify(b"Hello world !!") to get hex string. b":".join(h[i:i+2] for i in range(0, len(h), 2))aby wstawić ':'po każdych dwóch cyfrach szesnastkowych.
jfs

2
Nie działa w Pythonie 3.LookupError: 'hex' is not a text encoding; use codecs.encode() to handle arbitrary codecs
Boris

55

W przypadku Pythona 2.x:

':'.join(x.encode('hex') for x in 'Hello World!')

Powyższy kod nie będzie działał z Pythonem 3.x , dla 3.x będzie działał poniższy kod:

':'.join(hex(ord(x))[2:] for x in 'Hello World!')

1
należy również zauważyć, że późniejszy będzie działał RÓWNIEŻ z python2.x ORAZ będzie działał również dla znaków spoza ASCII
raudi

1
Należy jednak pamiętać, że ta ostatnia nie dopełnia zer wiodących: hex (ord ("\ x00")) [2:] to "0" i "\ x00" .encode ("hex") == "00"
Will Daniels

3
Dlaczego zdecydowałeś się opublikować to jako nową odpowiedź, miesiące po tym, jak oba te rozwiązania zostały zaoferowane przez innych użytkowników? Gdyby chodziło o wyjaśnienie zgodności wersji, bardziej sensowne byłoby sugerowanie zmian w istniejących odpowiedziach.
Air

2
Jak zauważono w innym miejscu, ta odpowiedź nie jest nawet poprawna, gdy wyjdziemy poza ascii i rozważymy Unicode. „:”. join (hex (ord (x)) [2:] for x in „løl”) niepoprawnie wyświetla „6c: f8: 6c”, podczas gdy prawidłowe wyjście to „6c: c3: b8: 6c”.
mcduffee

23

Kolejna odpowiedź w dwóch wierszach, która dla niektórych może być łatwiejsza do odczytania, i pomaga w debugowaniu podziałów wierszy lub innych dziwnych znaków w ciągu:

W przypadku Pythona 2.7

for character in string:
    print character, character.encode('hex')

Dla Pythona 3.7 (nie testowane we wszystkich wydaniach 3)

for character in string:
    print(character, character.encode('utf-8').hex())

To nie działa od Pythona 3.6.8 (przynajmniej): „hex” nie jest kodowaniem łańcuchów. codecs.encode(<bytestring>, "hex")jednak działa.
Eric O Lebigot

2
Ach, miłe dzięki za informację ... tak, to zdecydowanie zostało napisane dla Pythona 2.7. Zaktualizuję swoją odpowiedź, aby zawierała informacje, jak to zrobić dla Pythona 3.7.
copeland3300

Verified, Python 3.7.6: import sys; s="Déjà vu Besançon,Lupiñén,Šiauliai,Großräschen,Łódź,Аша,广东省,LA"; for c in s:; w=sys.stdout.write(c+":"+c.encode('utf-8').hex()+"||"); (out)D:44||é:c3a9||j:6a||à:c3a0|| :20||v:76||u:75|| :20||B:42||e:65||s:73||a:61||n:6e||ç:c3a7||o:6f||n:6e||,:2c||L:4c||u:75||p:70||i:69||ñ:c3b1||é:c3a9||n:6e||,:2c||Š:c5a0||i:69||a:61||u:75||l:6c||i:69||a:61||i:69||,:2c||G:47||r:72||o:6f||ß:c39f||r:72||ä:c3a4||s:73||c:63||h:68||e:65||n:6e||,:2c||Ł:c581||ó:c3b3||d:64||ź:c5ba||,:2c||А:d090||ш:d188||а:d0b0||,:2c||广:e5b9bf||东:e4b89c||省:e79c81||,:2c||L:4c||A:41||
bballdave025

20

Kilka uzupełnień do odpowiedzi Fedora Gogolewa:

Po pierwsze, jeśli ciąg zawiera znaki, których „kod ASCII” jest mniejszy niż 10, nie będą one wyświetlane zgodnie z wymaganiami. W takim przypadku prawidłowy format powinien wyglądać następująco {:02x}:

>>> s = "Hello unicode \u0005 !!"
>>> ":".join("{0:x}".format(ord(c)) for c in s)
'48:65:6c:6c:6f:20:75:6e:69:63:6f:64:65:20:5:20:21:21'
                                           ^

>>> ":".join("{:02x}".format(ord(c)) for c in s)
'48:65:6c:6c:6f:20:75:6e:69:63:6f:64:65:20:05:20:21:21'
                                           ^^

Po drugie, jeśli Twój „ciąg” jest w rzeczywistości „ciągiem bajtów” - a ponieważ różnica ma znaczenie w Pythonie 3 - możesz preferować następujące:

>>> s = b"Hello bytes \x05 !!"
>>> ":".join("{:02x}".format(c) for c in s)
'48:65:6c:6c:6f:20:62:79:74:65:73:20:05:20:21:21'

Należy pamiętać, że nie ma potrzeby konwersji w powyższym kodzie, ponieważ obiekty bajtów są zdefiniowane jako „niezmienna sekwencja liczb całkowitych z zakresu 0 <= x <256” .


11

Wydrukować ciąg jako bajty szesnastkowe?

Zaakceptowana odpowiedź daje:

s = "Hello world !!"
":".join("{:02x}".format(ord(c)) for c in s)

zwroty:

'48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21'

Zaakceptowana odpowiedź działa tylko wtedy, gdy używasz bajtów (głównie znaków ascii). Ale jeśli używasz Unicode, np:

a_string = u"Привет мир!!" # "Prevyet mir", or "Hello World" in Russian.

Musisz jakoś przekonwertować na bajty.

Jeśli twój terminal nie akceptuje tych znaków, możesz dekodować z UTF-8 lub użyć nazw (abyś mógł wkleić i uruchomić kod razem ze mną):

a_string = (
    "\N{CYRILLIC CAPITAL LETTER PE}"
    "\N{CYRILLIC SMALL LETTER ER}"
    "\N{CYRILLIC SMALL LETTER I}"
    "\N{CYRILLIC SMALL LETTER VE}"
    "\N{CYRILLIC SMALL LETTER IE}"
    "\N{CYRILLIC SMALL LETTER TE}"
    "\N{SPACE}"
    "\N{CYRILLIC SMALL LETTER EM}"
    "\N{CYRILLIC SMALL LETTER I}"
    "\N{CYRILLIC SMALL LETTER ER}"
    "\N{EXCLAMATION MARK}"
    "\N{EXCLAMATION MARK}"
)

Więc widzimy, że:

":".join("{:02x}".format(ord(c)) for c in a_string)

zwroty

'41f:440:438:432:435:442:20:43c:438:440:21:21'

słaby / nieoczekiwany wynik - są to punkty kodowe, które razem tworzą grafemy, które widzimy w Unicode, pochodzące z Konsorcjum Unicode - reprezentujące języki na całym świecie. Nie jest to jednak sposób, w jaki faktycznie przechowujemy te informacje, aby mogły być interpretowane przez inne źródła.

Aby umożliwić innemu źródłu korzystanie z tych danych, zwykle musielibyśmy przekonwertować je na kodowanie UTF-8, na przykład, aby zapisać ten ciąg w bajtach na dysk lub opublikować w formacie html. Więc potrzebujemy tego kodowania, aby przekonwertować punkty kodowe na jednostki kodu UTF-8 - w Pythonie 3, ordnie jest potrzebne, ponieważ bytessą iterowalne liczb całkowitych:

>>> ":".join("{:02x}".format(c) for c in a_string.encode('utf-8'))
'd0:9f:d1:80:d0:b8:d0:b2:d0:b5:d1:82:20:d0:bc:d0:b8:d1:80:21:21'

A może bardziej elegancko, używając nowych f-stringów (dostępnych tylko w Pythonie 3):

>>> ":".join(f'{c:02x}' for c in a_string.encode('utf-8'))
'd0:9f:d1:80:d0:b8:d0:b2:d0:b5:d1:82:20:d0:bc:d0:b8:d1:80:21:21'

W Pythonie 2 przejdź cdo ordpierwszego, czyli ord(c)- więcej przykładów:

>>> ":".join("{:02x}".format(ord(c)) for c in a_string.encode('utf-8'))
'd0:9f:d1:80:d0:b8:d0:b2:d0:b5:d1:82:20:d0:bc:d0:b8:d1:80:21:21'
>>> ":".join(format(ord(c), '02x') for c in a_string.encode('utf-8'))
'd0:9f:d1:80:d0:b8:d0:b2:d0:b5:d1:82:20:d0:bc:d0:b8:d1:80:21:21'

1
@ not2qubit, spróbuj ponownie tych przykładów - poświęciłem trochę czasu, aby rozwiązać różnice między Pythonem 2 i 3, i najwyraźniej pierwotnie napisałem je tylko dla Pythona 2. Dziękuję za odpowiedź QA!
Aaron Hall

Tak, to wystarczyło. Dziękuję Ci!
not2qubit

8

Możesz użyć hexdump's

import hexdump
hexdump.dump("Hello World", sep=":")

(dołącz, .lower()jeśli potrzebujesz małych liter). Działa to zarówno w Pythonie 2, jak i 3.


Również problem, na który natknąłem się, jeśli masz problemy z instalacją hexdump lub jakiegokolwiek innego pakietu, jest to zwykle spowodowane ustawieniami proxy, spróbuj uruchomić pip z opcją proxy pip install -U hexdump --proxy http://proxy.address:port
Eduard Florinescu

Właściwie popełniłem błąd, używając sudoz pip, co pomieszało pacman...
Tobias Kienzler

6

Użycie mapy i funkcji lambda może wygenerować listę wartości szesnastkowych, które można wydrukować (lub wykorzystać do innych celów)

>>> s = 'Hello 1 2 3 \x01\x02\x03 :)'

>>> map(lambda c: hex(ord(c)), s)
['0x48', '0x65', '0x6c', '0x6c', '0x6f', '0x20', '0x31', '0x20', '0x32', '0x20', '0x33', '0x20', '0x1', '0x2', '0x3', '0x20', '0x3a', '0x29']

[hex(ord(c)) for c in s]
Boris

2

Można to zrobić na następujące sposoby:

from __future__ import print_function
str = "Hello World !!"
for char in str:
    mm = int(char.encode('hex'), 16)
    print(hex(mm), sep=':', end=' ' )

Wynik tego będzie w postaci szesnastkowej w następujący sposób:

0x48 0x65 0x6c 0x6c 0x6f 0x20 0x57 0x6f 0x72 0x6c 0x64 0x20 0x21 0x21


gdzie znajdę przyszłość
tofutim

Na przyszłość __future__jest to standardowa biblioteka dostępna w najnowszych wersjach Pythona 2, która może być używana do normalnego tworzenia funkcji tylko w Pythonie 3 w celu zapewnienia zgodności wstecznej. W tej odpowiedzi jest używany do uzyskania funkcji print(text)„print function”, która zastępuje print textskładnię z Pythona 2. Zobacz dokumentację Pythona .
Eric Reed

2

Nieco bardziej ogólny dla tych, którzy nie dbają o Python3 lub dwukropki:

from codecs import encode

data = open('/dev/urandom', 'rb').read(20)
print(encode(data, 'hex'))      # data

print(encode(b"hello", 'hex'))  # string

0

Używanie base64.b16encodew python2 (jego wbudowane)

>>> s = 'Hello world !!'
>>> h = base64.b16encode(s)
>>> ':'.join([h[i:i+2] for i in xrange(0, len(h), 2)]
'48:65:6C:6C:6F:20:77:6F:72:6C:64:20:21:21'

To nie działa. Czego używasz do importu i dlaczego nie używać .decode()?
not2qubit

0

Dla wygody, bardzo proste.

def hexlify_byteString(byteString, delim="%"):
    ''' very simple way to hexlify a bytestring using delimiters '''
    retval = ""
    for intval in byteString:
        retval += ( '0123456789ABCDEF'[int(intval / 16)])
        retval += ( '0123456789ABCDEF'[int(intval % 16)])
        retval += delim
    return( retval[:-1])

hexlify_byteString(b'Hello World!', ":")
# Out[439]: '48:65:6C:6C:6F:20:57:6F:72:6C:64:21'

0

w przypadku czegoś, co oferuje większą wydajność niż ''.format(), możesz użyć tego:

>>> ':'.join( '%02x'%(v if type(v) is int else ord(v)) for v in 'Hello World !!' )
'48:65:6C:6C:6F:20:77:6F:72:6C:64:20:21:21'
>>> 
>>> ':'.join( '%02x'%(v if type(v) is int else ord(v)) for v in b'Hello World !!' )
'48:65:6C:6C:6F:20:77:6F:72:6C:64:20:21:21'
>>> 

przepraszam, że to nie mogłoby wyglądać ładniej,
byłoby fajnie, gdyby można było po prostu to zrobić '%02x'%v, ale to wymaga tylko int ...
ale utkniesz z ciągami bajtów b''bez logiki do wyboru ord(v).

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.