Imprimir uma string como bytes hexadecimais?

155

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?

Eduard Florinescu
fonte
Se a idéia é retornar apenas valores hexadecimais de 2 dígitos, essa pergunta implica o uso de cadeias de bytes (por exemplo, Python 2 strou Python 3 bytestring), pois não há transformação inequívoca de um caractere em um número inteiro de 0 a 255. Assim, as cadeias de caracteres (Python 2 unicodee Python 3 str) primeiro requerem alguma codificação antes de serem conversíveis neste formato hexadecimal. A resposta de Aaron Hall exemplifica isso.
Eric O Lebigot

Respostas:

227

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
Fedor Gogolev
fonte
3
Observe que no python3, o conceito de imprimir um strcomo hex não faz muito sentido; convém imprimir o bytesobjeto como hexadecimal (converter strpara byteschamando .encode()).
8135 mic_e
8
De fato, isso produz resultados inválidos em python3: ":".join("{:02x}".format(ord(c)) for c in 'løl')retorna '6c:f8:6c', enquanto ":".join("{:02x}".format(c) for c in 'løl'.encode())produz a representação correta do utf-8 '6c:c3:b8:6c'.
8195 mic_e
2
Esta pergunta e resposta assumem que sua entrada nunca contém caracteres não-ASCII. Se a sua entrada pode conter coisas como emojis ou sistemas de escrita da base não-latinos, você pode querer usar ":".join("{:04x}".format(ord(c)) for c in s)(substituindo 02xcom 04xa zero-pad cada número a ser 4 dígitos) em vez
Boris
@mic_e Por que isso? Scapy faz uma referência a isso quando você tenta no intérprete incorporado. WARNING: Calling str(pkt) on Python 3 makes no sense!
sherrellbc 20/07
157
':'.join(x.encode('hex') for x in 'Hello World!')
Esthete
fonte
3
Como fazer isso em 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))para inserir ':'após cada dois dígitos hexadecimais.
JFS
2
Não funciona em Python 3.LookupError: 'hex' is not a text encoding; use codecs.encode() to handle arbitrary codecs
Boris
55

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!')
Kelvin Hu
fonte
1
ele também deve ser observado, que mais tarde também funcionará com python2.x e vai também trabalhar para caracteres não-ascii
raudi
1
Mas observe também que este último não preenche zeros à esquerda: hex (ord ("\ x00")) [2:] é "0" e "\ x00" .encode ("hex") == "00"
Will Daniels
3
Por que você decidiu postar isso como uma nova resposta, meses depois que essas duas soluções foram oferecidas por outros usuários? Se o objetivo era esclarecer a compatibilidade da versão, faria mais sentido sugerir edições nas respostas existentes.
Air
2
Como observado em outro lugar, essa resposta nem sequer está correta quando alguém ultrapassa ascii e considera o unicode. ':'. join (hex (ord (x)) [2:] para x em 'løl') imprime incorretamente '6c: f8: 6c' enquanto a saída correta é '6c: c3: b8: 6c'.
Mcduffee
23

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())
copeland3300
fonte
Isso não funciona no Python 3.6.8 (pelo menos): "hex" não é uma codificação de strings. codecs.encode(<bytestring>, "hex")funciona, no entanto.
Eric O Lebigot
2
Ah, obrigado pela informação ... sim, isso foi definitivamente escrito para o Python 2.7. Atualizarei minha resposta para incluir como fazê-lo no Python 3.7.
precisa
Verificado, 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

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

Sylvain Leroux
fonte
11

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'
Aaron Hall
fonte
1
@ not2qubit, tente estes exemplos novamente - Demorei um pouco para resolver as diferenças entre o Python 2 e 3 e, aparentemente, originalmente eu as escrevi apenas para o Python 2. E obrigado por responder minha pergunta!
Aaron Hall
Sim, foi isso. Obrigado!
#
8

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.

Tobias Kienzler
fonte
Também um problema que eu tive, se você tiver problemas para instalar hexdump ou qualquer outro pacote é usualy por causa das configurações de proxy tentar executar pip com a opção de proxy pip install -U hexdump --proxy http://proxy.address:port
Eduard Florinescu
Na verdade, eu cometi o erro de usar sudocom pipque errei pacman...
Tobias KIENZLER
6

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']
BrendanSimon
fonte
[hex(ord(c)) for c in s]
Boris
2

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

Ghansham
fonte
Onde eu encontro o futuro
tofutim 29/03
Para referência futura, __future__é uma biblioteca padrão disponível nas versões recentes do Python 2 que pode ser usada para criar recursos normalmente apenas no Python 3 compatível com versões anteriores. Nesta resposta, é usado para obter o print(text)recurso "função de impressão", que substitui a print textsintaxe do Python 2. Consulte os documentos do Python .
Eric Reed
2

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
Gringo Suave
fonte
0

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'
Shiplu Mokaddim
fonte
Isso não funciona. O que você está usando para importação e por que não usar .decode()?
Not2qubit #
0

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'
BerndSchmitt
fonte
0

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

Tcll
fonte