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ć?

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

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

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

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

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

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'

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.

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

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

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

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'

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'

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