Como converter strings em bytes em Python

As strings representam texto legível por humanos e são um dos tipos de dados mais básicos e importantes na programação de computadores. No entanto, cada caractere em uma string de texto é representado por um ou mais bytes de dados binários. Aplicativos como operações de entrada e saída e transmissão de dados exigem que as cadeias de caracteres sejam convertidas em bytes usando uma codificação específica.

Este tutorial explora as técnicas de conversão de strings em bytes em Python. Se você estiver interessado na operação inversa, confira meu tutorial sobre como converter bytes em strings em Python.

Antes de entrar em detalhes, vamos começar com uma resposta curta para aqueles que estão com pressa.

Resposta curta: Como converter strings em bytes em Python

O Python facilita a conversão de uma string em bytes usando o método nativo .encode():

my_string = "Hello, world!"
bytes_representation = my_string.encode(encoding="utf-8")  
# Optional: Specify the desired encoding (UTF-8 is the default)

print(bytes_representation)
# Output: b'Hello, world!'

O método .encode() retorna um novo objeto bytes que representa a versão codificada da cadeia de caracteres original. Por padrão, ele usa a codificação UTF-8, mas você pode especificar outras codificações, como 'ascii' ou 'latin-1', se necessário.

Vamos explorar esse processo de conversão em mais detalhes.

Entendendo strings e bytes em Python

Dois dos principais tipos de dados nativos do Python são str e bytes. Esses tipos de dados compartilham recursos comuns, mas têm diferenças importantes.

Tanto str quanto bytes são sequências imutáveis, ​o que significa que não podemos modificar seus elementos após a criação. Uma string é uma sequência imutável de caracteres, enquanto um objeto bytes é uma sequência imutável de números inteiros entre 0 e 255. Esse intervalo de números inteiros pode ser representado por 8 bits, ou seja, um byte. Portanto, um objeto bytes é uma sequência de bytes.

Codificação de caracteres ASCII

Vamos considerar primeiro os caracteres ASCII. ASCII (American Standard Code for Information Interchange) é uma codificação de caracteres que contém apenas 128 caracteres. Portanto, qualquer caractere ASCII pode ser representado por sete bits, o que é menos do que um único byte.

Podemos criar um objeto bytes adicionando b na frente das aspas simples, duplas ou triplas que normalmente usamos para strings:

word_as_bytes = b"Python"
print(word_as_bytes)
print(type(word_as_bytes))

b'Python'
<class 'bytes'>

Embora o código exiba os caracteres com a grafia Python, cada elemento do objeto bytes é um número inteiro entre 0 e 255:

print(word_as_bytes[0])
print(list(word_as_bytes))

80
[80, 121, 116, 104, 111, 110]

O primeiro elemento de word_as_bytes é o número inteiro 80, que é o código ASCII para P maiúsculo:

print(chr(80))

P

Ao converter word_as_bytes em uma lista, a lista contém os inteiros que representam cada byte. Os números inteiros são os códigos ASCII para as letras da palavra Python.

No entanto, o conjunto de caracteres ASCII é limitado.

Codificação de caracteres UTF-8

A codificação de caracteres mais comum é a UTF-8, que é uma codificação Unicode de 8 bits. Os 128 caracteres ASCII são representados pelos mesmos números inteiros em UTF-8, mas outros caracteres também podem ser representados usando dois ou mais bytes para cada caractere.

Vamos criar um objeto bytes usando caracteres não ASCII. Precisaremos usar o construtor bytes():

word_as_bytes = bytes("café", "utf-8")
print(word_as_bytes)

b'caf\xc3\xa9'

O objeto bytes exibe diretamente as três primeiras letras de café. No entanto, o é acentuado não é um caractere ASCII e é representado por dois bytes, que são exibidos como \xc3 e \xa9. Esses bytes representam os números hexadecimais c3 e a9, que são os números inteiros 195 e 169. Esses dois bytes combinados representam é em UTF-8:

print(len(word_as_bytes))
print(list(word_as_bytes))

5
[99, 97, 102, 195, 169]

Um objeto bytes de cinco elementos representa a cadeia de quatro letras.

Conversão de strings em bytes: O método encode()

Anteriormente, usamos o construtor bytes() para converter uma string de texto em um objeto bytes. Uma maneira mais comum de converter strings Python em bytes é usar o método .encode() de string, que oferece controle sobre a codificação e o tratamento de erros. Esse método retorna um objeto bytes que representa a string:

word_as_bytes = "Hello Python!".encode()
​print(word_as_bytes)
print(type(word_as_bytes))

b'Hello Python!'
<class 'bytes'>

O método .encode() tem como padrão a codificação UTF-8. O UTF-8 é o formato de codificação mais amplamente usado e oferece suporte a uma variedade muito maior de caracteres do que o ASCII. O UTF-8 representa cada caractere com uma sequência de unidades de um, dois, três ou quatro bytes.

Podemos chamar .encode() com uma codificação alternativa como argumento:

word_as_bytes = "Hello Python!".encode("utf-16")
print(word_as_bytes)

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00 \x00P\x00y\x00t\x00h\x00o\x00n\x00!\x00'

O objeto bytes é diferente nesse caso, pois representa a codificação UTF-16 da mesma string de texto.

Erros de codificação

Como nem todas as codificações incluem todos os caracteres, podem ocorrer erros ao codificar uma cadeia de caracteres em um objeto bytes.

Vamos considerar a string "Café • £2.20", que tem três caracteres não ASCII. Podemos codificar isso usando a codificação UTF-8 padrão:

word_as_bytes = "Café • £2.20".encode()
print(word_as_bytes)

b'Caf\xc3\xa9 \xe2\x80\xa2 \xc2\xa32.20'

Os caracteres não ASCII são substituídos por suas sequências de escape hexadecimais. No entanto, .encode() gera um erro se a mesma cadeia de caracteres for codificada usando ASCII, pois vários caracteres não estão presentes na codificação ASCII:

word_as_bytes = "Café • £2.20".encode("ascii")
print(word_as_bytes)

Traceback (most recent call last):
...
word_as_bytes = "Café • £2.20".encode("ascii")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3: ordinal not in range(128)

O método .encode() de string tem um parâmetro errors, que tem um valor padrão de "strict". O argumento "strict" força o método .encode() a gerar um UnicodeEncodeError quando um caractere não puder ser codificado.

No entanto, há outras opções para o tratamento de erros. Uma opção é ignorar os erros usando o argumento "ignore":

word_as_bytes = "Café • £2.20".encode("ascii", errors="ignore")
print(word_as_bytes)

b'Caf 2.20'

Essa opção não gera um erro. Em vez disso, .encode() retorna um objeto bytes, e o é acentuado, o marcador e o sinal de libra são omitidos.

Outra opção é substituir os caracteres que não podem ser codificados por outra coisa. Há várias opções de substituição. Um deles é o argumento errors="replace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="replace")
print(word_as_bytes)

b'Caf? ? ?2.20'

Os três caracteres não ASCII, que não podem ser codificados neste exemplo, são substituídos por um ponto de interrogação. Portanto, cada caractere faltante é substituído por outro caractere único que funciona como um espaço reservado.

Também podemos substituir os caracteres faltantes por um texto mais informativo:

word_as_bytes = "Café • £2.20".encode("ascii", errors="backslashreplace")
print(word_as_bytes)

b'Caf\\xe9 \\u2022 \\xa32.20'

Chamar .encode() com errors="backslashreplace" substitui os caracteres que não podem ser codificados por suas sequências de escape hexadecimais. O número hexadecimal e9 representa o é acentuado. O marcador é o caractere Unicode u2022, e o número hexadecimal a3 representa o sinal de libra.

Também podemos usar "xmlcharrefreplace" para substituir os caracteres faltantes por seu código XML:

word_as_bytes = "Café • £2.20".encode("ascii", errors="xmlcharrefreplace")
print(word_as_bytes)

b'Café • £2.20'

Outra opção é substituir os caracteres inválidos por seus nomes formais usando errors="namereplace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="namereplace")
print(word_as_bytes)

b'Caf\\N{LATIN SMALL LETTER E WITH ACUTE} \\N{BULLET} \\N{POUND SIGN}2.20'

Situações diferentes podem exigir um tratamento de erros personalizado, e o método .encode() de string oferece várias opções para lidar com caracteres que não podem ser codificados.

Aplicações da conversão de cadeia de caracteres para bytes na ciência de dados

A conversão de string para byte é uma operação fundamental que encontra aplicações em vários domínios da ciência de dados:

• Processamento de linguagem natural (PNL). Ao trabalhar com dados de texto para tarefas como análise de sentimentos, modelagem de tópicos ou tradução automática, geralmente pré-processamos o texto por meio de tokenização em palavras ou subpalavras. Esse processo de tokenização frequentemente envolve a conversão de cadeias de caracteres em sequências de bytes para representação e manipulação eficientes.
• Limpeza e pré-processamento de dados: As operações em nível de byte podem ser úteis para a limpeza de dados de texto, como a remoção de caracteres inválidos ou a normalização de texto com base em padrões de byte específicos.
• Engenharia de atributos: Em alguns casos, atributos em nível de byte (por exemplo, n-gramas de bytes) podem ser extraídos de dados de texto e usados como atributos de entrada em modelos de aprendizado de máquina.
• Raspagem da Web e extração de dados: Ao extrair dados de sites, geralmente recebemos HTML ou outro conteúdo baseado em texto que pode precisar ser analisado e processado em nível de byte para extrair informações relevantes.
• Compressão de dados: Certos algoritmos de compactação de dados operam em sequências de bytes, portanto, a conversão de strings em bytes pode ser uma etapa necessária antes da aplicação de técnicas de compactação.

A compreensão desses aplicativos pode nos ajudar a identificar situações em que a conversão de strings em bytes pode ser útil.

Conclusão

Strings são sequências de caracteres legíveis por humanos. Esses caracteres são codificados como bytes de dados binários, que podem ser armazenados em um objeto bytes. Um objeto bytes é uma sequência de números inteiros, e cada número inteiro representa um byte.

Os aplicativos exigem que as cadeias de caracteres sejam convertidas em objetos bytes, que podem ser convertidos usando o construtor bytes() ou o método .encode() de string. O domínio da conversão entre strings e bytes permite uma manipulação de dados mais flexível.

Você pode continuar seu aprendizado de Python com os seguintes tutoriais e cursos:

• Curso de Introdução ao Python
• Programação Python
• Fundamentos de Python