У мене є цей рядок: Hello world !!і я хочу роздрукувати його за допомогою Python як 48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21.

hex() працює лише для цілих чисел.

Як це можна зробити?

Ви можете перетворити рядок у генератор int, застосувати шістнадцяткове форматування для кожного елемента та інтеркалювати з роздільником:

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

Для Python 2.x:

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

Код, наведений вище, не працюватиме з Python 3.x , для 3.x, код нижче буде працювати:

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

Ще одна відповідь у двох рядках, яку деяким може бути легше читати, та допомагає при налагодженні розривів рядків або інших непарних символів у рядку:

Для Python 2.7

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

Для Python 3.7 (не тестується на всіх версіях 3)

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

Деякі доповнення до відповіді Федора Гоголєва:

По-перше, якщо рядок містить символи, "ASCII код" нижче 10, вони не відображатимуться як потрібно. У цьому випадку правильний формат повинен бути {: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'
                                           ^^

По-друге, якщо ваша "рядок" насправді є "байт-рядком" - а оскільки різниця має значення в Python 3 - ви можете віддати перевагу наступному:

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

Зверніть увагу, немає необхідності в перетворенні вищевказаного коду, оскільки об'єкти байтів визначаються як "незмінна послідовність цілих чисел у діапазоні 0 <= x <256" .

Друкувати рядок у вигляді шістнадцяткових байтів?

Прийнята відповідь дає:

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'

Прийнята відповідь працює лише до тих пір, поки ви використовуєте байти (в основному символи ascii). Але якщо ви використовуєте unicode, наприклад:

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

Вам потрібно якось перетворити в байти.

Якщо ваш термінал не приймає цих символів, ви можете декодувати з UTF-8 або використовувати імена (щоб ви могли вставити і запустити код разом зі мною):

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}"
)

Отже, ми бачимо це:

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

повертає

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

поганий / несподіваний результат - це кодові пункти, які поєднують, щоб зробити графеми, які ми бачимо в Unicode, від консорціуму Unicode - представляючи мови у всьому світі. Це НЕ як ми на самому справі зберігати цю інформацію , так що може бути інтерпретовано іншими джерелами, однако.

Щоб дозволити іншому джерелу використовувати ці дані, зазвичай нам потрібно було б перетворити в кодування UTF-8, наприклад, зберегти цю рядок у байтах на диску або опублікувати в html. Тож нам потрібно, що кодування для перетворення точок коду в одиниці коду UTF-8 - в Python 3, ordне потрібно, оскільки bytesце ітерабелі цілих чисел:

>>> ":".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'

Або, можливо, більш елегантно, використовуючи нові f-рядки (доступні лише в Python 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'

У Python 2 перейдіть cдо ordпершого, тобто ord(c)- більше прикладів:

>>> ":".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'

Ви можете використовувати hexdumps

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

(додайте, .lower()якщо вам потрібні малі регістри). Це працює як для Python 2, так і для 3.

Використовуючи функцію map та lambda, можна створити список шістнадцяткових значень, які можна надрукувати (або використовувати для інших цілей)

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

Це можна зробити наступними способами:

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

Вихід цього буде у шістнадцятковій формі:

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

Трохи більш загальне для тих, хто не переймається Python3 або колонами:

from codecs import encode

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

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

Використання base64.b16encodeв python2 (його вбудований)

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

Просто для зручності, дуже просто.

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'

для чогось, що пропонує більшу ефективність ''.format(), ви можете використовувати це:

>>> ':'.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'
>>> 

Вибачте, це не могло виглядати приємніше,
було б добре, якби можна було просто зробити'%02x'%v , але це вимагає лише int ...
але ви будете застрягли в рядках байтів b''без логіки для вибору ord(v).