Cómo convertir cadenas en bytes en Python

Las cadenas representan texto legible por humanos y son uno de los tipos de datos más básicos e importantes de la programación informática. Sin embargo, cada carácter de una cadena de texto está representado por uno o varios bytes de datos binarios. Aplicaciones como las operaciones de entrada y salida y la transmisión de datos requieren que las cadenas se conviertan en bytes utilizando una codificación específica.

Este tutorial explora las técnicas de conversión de cadenas a bytes en Python. Si te interesa la operación inversa, consulta mi tutorial sobre cómo convertir bytes en cadenas en Python.

Antes de entrar en detalles, empecemos con una respuesta breve para los que tengáis prisa.

Respuesta corta: cómo convertir cadenas en bytes en Python

Python facilita la conversión de una cadena en bytes mediante el método incorporado .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!'

El método .encode() devuelve un nuevo objeto bytes que representa la versión codificada de la cadena original. Por defecto, utiliza la codificación UTF-8, pero puedes especificar otras codificaciones como 'ascii' o 'latin-1' si es necesario.

Exploremos este proceso de conversión con más detalle.

Comprender las cadenas y los bytes en Python

Dos de los principales tipos de datos incorporados en Python son str y bytes. Estos tipos de datos comparten características comunes, pero tienen diferencias clave.

Tanto str como bytes son secuencias inmutables, ​lo que significa que no podemos modificar sus elementos después de la creación. Una cadena es una secuencia inmutable de caracteres, mientras que un objeto bytes es una secuencia inmutable de números enteros entre 0 y 255. Este rango de enteros puede representarse con 8 bits, que es un byte. Por tanto, un objeto bytes es una secuencia de bytes.

Codificación de caracteres ASCII

Consideremos primero los caracteres ASCII. ASCII (American Standard Code for Information Interchange) es una codificación de caracteres que sólo contiene 128 caracteres. Por tanto, cualquier carácter ASCII puede representarse con siete bits, que es menos que un byte.

Podemos crear un objeto bytes añadiendo b delante de las comillas simples, dobles o triples que utilizamos normalmente para las cadenas:

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

b'Python'
<class 'bytes'>

Aunque el código muestra los caracteres deletreando Python, cada elemento del objeto bytes es un número entero entre 0 y 255:

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

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

El primer elemento de word_as_bytes es el entero 80, que es el código ASCII de la P mayúscula:

print(chr(80))

P

Al convertir word_as_bytes en una lista, la lista contiene los enteros que representan cada byte. Los números enteros son los códigos ASCII de las letras de la palabra Python.

Sin embargo, el conjunto de caracteres ASCII es limitado.

Codificación de caracteres UTF-8

La codificación de caracteres más común es UTF-8, que es una codificación Unicode de 8 bits. Los 128 caracteres ASCII se representan con los mismos enteros en UTF-8, pero otros caracteres también pueden representarse utilizando dos o más bytes para cada carácter.

Vamos a crear un objeto bytes utilizando caracteres no ASCII. Tendremos que utilizar el constructor bytes():

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

b'caf\xc3\xa9'

El objeto bytes muestra directamente las tres primeras letras de café. Sin embargo, la é acentuada no es un carácter ASCII, y está representada por dos bytes, que se muestran como \xc3 y \xa9. Estos bytes representan los números hexadecimales c3 y a9, que son los enteros 195 y 169. Estos dos bytes combinados representan é en UTF-8:

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

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

Un objeto bytes de cinco elementos representa la cadena de cuatro letras.

Convertir cadenas en bytes: el método encode()

Antes hemos utilizado el constructor bytes() para convertir una cadena de texto en un objeto bytes. Una forma más habitual de convertir cadenas de Python a bytes es utilizar el método de cadena .encode(), que permite controlar la codificación y el tratamiento de errores. Este método devuelve un objeto bytes que representa la cadena:

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

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

El método .encode() utiliza por defecto la codificación UTF-8. UTF-8 es el formato de codificación más utilizado, y admite una gama de caracteres mucho más amplia que ASCII. UTF-8 representa cada carácter con una secuencia de unidades de uno, dos, tres o cuatro bytes.

Podemos llamar a .encode() con una codificación 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'

El objeto bytes es diferente en este caso, ya que representa la codificación UTF-16 de la misma cadena de texto.

Errores de codificación

Como no todas las codificaciones incluyen todos los caracteres, pueden producirse errores al codificar una cadena en un objeto bytes.

Consideremos la cadena "Café • £2.20", que tiene tres caracteres no ASCII. Podemos codificarlo utilizando la codificación UTF-8 por defecto:

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

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

Los caracteres no ASCII se sustituyen por sus secuencias de escape hexadecimales. Sin embargo, .encode() produce un error si la misma cadena se codifica utilizando ASCII, ya que varios caracteres no están presentes en la codificación 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)

El método de cadena .encode() tiene un parámetro errors, cuyo valor por defecto es "strict". El argumento "strict" obliga a .encode() a emitir un UnicodeEncodeError cuando no se pueda codificar un carácter.

Sin embargo, hay otras opciones para tratar los errores. Una opción es ignorar los errores utilizando el argumento "ignore":

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

b'Caf 2.20'

Esta opción no provoca ningún error. En su lugar, .encode() devuelve un objeto bytes, y se omiten la é acentuada, el punto y la almohadilla.

Otra opción es sustituir los caracteres que no se pueden codificar por otra cosa. Hay varias opciones de sustitución. Uno de ellos es el argumento errors="replace":

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

b'Caf? ? ?2.20'

Los tres caracteres no ASCII, que no se pueden codificar en este ejemplo, se sustituyen por un signo de interrogación. Por lo tanto, cada carácter que falta se sustituye por otro carácter único que actúa como marcador de posición.

También podemos sustituir los caracteres que faltan por un texto más informativo:

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

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

Al llamar a .encode() con errors="backslashreplace" se sustituyen los caracteres que no se pueden codificar por sus secuencias de escape hexadecimales. El número hexadecimal e9 representa la é acentuada. La viñeta es el carácter Unicode u2022, y el número hexadecimal a3 representa el símbolo almohadilla.

También podemos utilizar "xmlcharrefreplace" para sustituir los caracteres que faltan por su código XML:

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

b'Café • £2.20'

Otra opción es sustituir los caracteres no válidos por su nombre formal utilizando 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'

Diferentes situaciones pueden requerir un tratamiento de errores a medida, y el método de cadena .encode() ofrece varias opciones para tratar los caracteres que no se pueden codificar.

Aplicaciones de la conversión cadena a byte en la ciencia de datos

La conversión de cadena a byte es una operación fundamental que encuentra aplicaciones en diversos dominios de la ciencia de datos:

• Procesamiento del lenguaje natural (PLN). Cuando trabajamos con datos de texto para tareas como el análisis de opinión, el modelado de temas o la traducción automática, a menudo preprocesamos el texto dividiéndolo en palabras o subpalabras. Este proceso de tokenización implica frecuentemente convertir cadenas en secuencias de bytes para una representación y manipulación eficaces.
• Limpieza y preprocesamiento de datos: Las operaciones a nivel de byte pueden ser útiles para limpiar datos de texto, como eliminar caracteres no válidos o normalizar el texto basándose en patrones específicos de bytes.
• Ingeniería de características: En algunos casos, las características a nivel de byte (por ejemplo, n-gramas de bytes) pueden extraerse de los datos de texto y utilizarse como características de entrada para los modelos de machine learning.
• Raspado web y extracción de datos: Al raspar datos de sitios web, a menudo recibimos HTML u otro contenido basado en texto que puede necesitar ser analizado y procesado a nivel de bytes para extraer información relevante.
• Compresión de datos: Algunos algoritmos de compresión de datos funcionan con secuencias de bytes, por lo que convertir cadenas en bytes puede ser un paso necesario antes de aplicar técnicas de compresión.

Comprender estas aplicaciones puede ayudarnos a identificar situaciones en las que puede ser útil convertir cadenas en bytes.

Conclusión

Las cadenas son secuencias de caracteres legibles por humanos. Estos caracteres se codifican como bytes de datos binarios, que pueden almacenarse en un objeto bytes. Un objeto bytes es una secuencia de números enteros, y cada número entero representa un byte.

Las aplicaciones requieren que las cadenas se conviertan en objetos bytes, que podemos convertir utilizando el constructor bytes() o el método de cadena .encode(). Dominar la conversión entre cadenas y bytes permite una manipulación más flexible de los datos.

Puedes continuar tu aprendizaje de Python con los siguientes tutoriales y cursos:

• Curso de Introducción a Python
• Programación en Python
• Fundamentos de Python