J'ai cette chaîne: Hello world !!et je veux l'imprimer en utilisant Python comme 48:65:6c:6c:6f:20:77:6f:72:6c:64:20:21:21.

hex() ne fonctionne que pour les entiers.

Comment ceci peut être fait?

Vous pouvez transformer votre chaîne en un générateur int, appliquer une mise en forme hexadécimale pour chaque élément et intercaler avec un séparateur:

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

Pour Python 2.x:

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

Le code ci-dessus ne fonctionnera pas avec Python 3.x , pour 3.x, le code ci-dessous fonctionnera:

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

Une autre réponse en deux lignes que certains pourraient trouver plus facile à lire et qui aide au débogage des sauts de ligne ou d'autres caractères impairs dans une chaîne:

Pour Python 2.7

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

Pour Python 3.7 (non testé sur toutes les versions de 3)

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

Quelques compléments à Fedor Gogolev répondent:

Premièrement, si la chaîne contient des caractères dont le «code ASCII» est inférieur à 10, ils ne seront pas affichés comme requis. Dans ce cas, le format correct doit être {: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'
                                           ^^

Deuxièmement, si votre "chaîne" est en réalité une "chaîne d'octets" - et puisque la différence compte dans Python 3 - vous préférerez peut-être ce qui suit:

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

Veuillez noter qu'il n'y a pas besoin de conversion dans le code ci-dessus car un objet bytes est défini comme "une séquence immuable d'entiers dans la plage 0 <= x <256" .

Imprimer une chaîne sous forme d'octets hexadécimaux?

La réponse acceptée donne:

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

Retour:

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

La réponse acceptée ne fonctionne que tant que vous utilisez des octets (principalement des caractères ascii). Mais si vous utilisez unicode, par exemple:

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

Vous devez d'une manière ou d'une autre convertir en octets.

Si votre terminal n'accepte pas ces caractères, vous pouvez décoder à partir de UTF-8 ou utiliser les noms (vous pouvez donc coller et exécuter le code avec moi):

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

Nous voyons donc que:

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

Retour

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

un résultat médiocre / inattendu - ce sont les points de code qui se combinent pour former les graphèmes que nous voyons dans Unicode, du consortium Unicode - représentant des langues du monde entier. Ce n'est pas ainsi que nous stockons ces informations afin qu'elles puissent être interprétées par d'autres sources, cependant.

Pour permettre à une autre source d'utiliser ces données, nous aurions généralement besoin de convertir en encodage UTF-8, par exemple, pour enregistrer cette chaîne en octets sur le disque ou pour la publier en html. Nous avons donc besoin de cet encodage pour convertir les points de code en unités de code de UTF-8 - en Python 3, ordn'est pas nécessaire car il bytesexiste des itérables d'entiers:

>>> ":".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 peut-être plus élégamment, en utilisant les nouvelles f-strings (uniquement disponibles en 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'

En Python 2, passez cau ordpremier, c'est ord(c)-à- dire - plus d'exemples:

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

Vous pouvez utiliser hexdumples

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

(ajoutez .lower()si vous avez besoin de minuscules). Cela fonctionne pour Python 2 et 3.

L'utilisation de la carte et de la fonction lambda peut produire une liste de valeurs hexadécimales, qui peuvent être imprimées (ou utilisées à d'autres 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']

Cela peut être fait des manières suivantes:

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

La sortie de ceci sera en hexadécimal comme suit:

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

Un peu plus général pour ceux qui ne se soucient pas de Python3 ou des deux-points:

from codecs import encode

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

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

Utilisation base64.b16encodeen python2 (son intégré)

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

Juste pour plus de commodité, très simple.

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'

pour quelque chose qui offre plus de performances que ''.format(), vous pouvez utiliser ceci:

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

désolé, cela ne pourrait pas être plus
beau, ce serait bien si on pouvait simplement le faire '%02x'%v, mais cela ne prend que des int ...
mais vous serez coincé avec des chaînes d'octets b''sans logique de sélection ord(v).