Eu tenho essa string: Hello world !!e quero imprimi-la usando Python como 48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21.

hex() funciona apenas para números inteiros.

Como pode ser feito?

Você pode transformar sua string em um gerador int, aplicar formatação hexadecimal para cada elemento e intercalar com separador:

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

Para Python 2.x:

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

O código acima não funcionará com o Python 3.x , para 3.x, o código abaixo funcionará:

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

Outra resposta em duas linhas que alguns podem achar mais fáceis de ler e ajuda na depuração de quebras de linha ou outros caracteres estranhos em uma sequência:

Para Python 2.7

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

Para Python 3.7 (não testado em todas as versões 3)

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

Alguns complementos à resposta de Fedor Gogolev:

Primeiro, se a string contiver caracteres cujo 'código ASCII' esteja abaixo de 10, eles não serão exibidos conforme necessário. Nesse caso, o formato correto deve ser {: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'
                                           ^^

Segundo, se a sua "string" é na realidade uma "string de bytes" - e como a diferença importa no Python 3 - você pode preferir o seguinte:

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

Observe que não há necessidade de conversão no código acima, pois um objeto bytes é definido como "uma sequência imutável de números inteiros no intervalo 0 <= x <256" .

Imprimir uma string como bytes hexadecimais?

A resposta aceita fornece:

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

retorna:

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

A resposta aceita funciona apenas desde que você use bytes (principalmente caracteres ascii). Mas se você usa unicode, por exemplo:

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

Você precisa converter para bytes de alguma forma.

Se o seu terminal não aceitar esses caracteres, você poderá decodificar a partir de UTF-8 ou usar os nomes (para colar e executar o código comigo):

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

Então vemos que:

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

retorna

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

um resultado ruim / inesperado - esses são os pontos de código que se combinam para criar os grafemas que vemos no Unicode, do Unicode Consortium - representando idiomas em todo o mundo. Isso é não como realmente armazenar essas informações para que possa ser interpretada por outras fontes, no entanto.

Para permitir que outra fonte use esses dados, geralmente precisamos converter para codificação UTF-8, por exemplo, para salvar essa string em bytes no disco ou publicar em html. Portanto, precisamos dessa codificação para converter os pontos de código nas unidades de código de UTF-8 - no Python 3, ordnão é necessária porque bytessão iteráveis ​​de números inteiros:

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

Ou talvez de forma mais elegante, usando as novas strings f (disponíveis apenas no 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'

No Python 2, passe cpara o ordprimeiro, ou seja, ord(c)- mais exemplos:

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

Você pode usar hexdump's

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

(acrescente .lower()se você precisar de letras minúsculas). Isso funciona para o Python 2 e 3.

O uso da função map e lambda pode produzir uma lista de valores hexadecimais, que podem ser impressos (ou usados ​​para outros fins)

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

Isso pode ser feito das seguintes maneiras:

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

A saída disso será em hexadecimal da seguinte maneira:

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

Um pouco mais geral para quem não se importa com Python3 ou dois pontos:

from codecs import encode

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

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

Usando base64.b16encodeem python2 (embutido)

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

Apenas por conveniência, muito simples.

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'

para algo que oferece mais desempenho do que ''.format(), você pode usar o seguinte:

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

desculpe, isso não poderia parecer melhor,
seria bom se alguém pudesse simplesmente fazê-lo '%02x'%v, mas isso leva apenas int ...
mas você ficará preso a cadeias de bytes b''sem a lógica para selecionar ord(v).