[vc_row][vc_column][vc_column_text]En Python 3, hay dos tipos que representar la secuencia de caracteres: bytes y str. Una instancia de bytes contiene un arreglo de 8 bits. La instancia de str contiene caracteres Unicode.
En Python 2, hay dos tipos que representan la secuencia de caracteres: str y unicode. A diferencia de Python 3, la instancia de str contiene un arreglo de 8 bits. La instancia de unicode contiene caracteres Unicode.
Hay muchas formas de representar los caracteres Unicode como data binaria (arreglo de 8 bits). La más común es la codificación UTF-8. Importante, la instancia de str en Python 3 y la instancia de unicode en Python 2 no tienen una codificación binaria asociada. Para convertir caracteres Unicode a data binaria, tiene que utilizar el método encode. Para convertir datos binarios en caracteres Unicode, tiene que utilizar el método decode.
Cuando escribe programas Python, es importante hacer codificación y decodificación de Unicode en el límite más lejano de sus interfaces. El corazón de su programa debe utilizar caracteres Unicode (str en Python 3 y unicode en Python 2) y no debería asumir nada sobre codificación de caracteres. Este enfoque le permite aceptar mucho las codificaciones de texto alternativa (como Latin-1, Shift JIIS y Big5) y se estricto con la codificación de texto de salida (idealmente, UTF-8).
La división entre los tipos de caracteres lleva a dos situaciones comunes en el código Python:
- Imagina que desea operar en valores brutos de 8 bits que son caracteres codificados en UTF-8 (u otra codificación)
- Imagina que desea operar con caracteres Unicode que no tienen una codificación específica
A menudo necesitará dos funciones de ayuda para convertir entres estos dos casos y para asegurarse de que el tipo de valores de entrada coincida con las expectativa de su código.
En Python 3, necesitarás un método que tome str o bytes y siempre devuelva str.
1 2 3 4 5 6 | def to_str(bytes_or_str): if isinstance(bytes_or_str, bytes): value = bytes_or_str.decode('utf-8') else: value = bytes_or_str return value # Instance of str |
También necesita otro método que tome str o bytes y siempre devuelva butes.
1 2 3 4 5 6 | def to_bytes(bytes_or_str): if isinstance(bytes_or_str, str): value = bytes_or_str.encode('utf-8') else: value = bytes_or_str return value # Instance of bytes |
En Python 2, necesita un método que tome str o unicode y siempre devuelva unicode.
1 2 3 4 5 6 7 | # Python 2 def to_unicode(unicode_or_str): if isinstance(unicode_or_str, str): value = unicode_or_str.decode('utf-8') else: value = unicode_or_str return value # Instance of unicode |
También necesita otro método que tome str o unicode y siempre devuelva str
1 2 3 4 5 6 7 | # Python 2 def to_str(unicode_or_str): if isinstance(unicode_or_str, unicode): value = unicode_or_str.encode('utf-8') else: value = unicode_or_str return value # Instance of str |
Hay dos grandes problemas cuando se trata de valores en bruto de 8 bits y caracteres Unicode en Python.
El primer problema es que Python 2, las instancias unicode y str parecen ser del mismo tipo cuando un str solo contiene caracteres ASCII de 7 bits.
- Imagine usted puede combinar tales str y unicode usando el operador +
- Imagine usted puede comparar tales instancias de str y unicode usando operadores de igualdad y desigualdad
- Imagine usted puede usar instancias de Unicode para cadenas de formato como «%s»
Todo este comportamiento significa que a menudo se puede pasar una instancia str o unicode a una función esperando uno u otro y las cosas simplemente funcionaran (siempre y cuando solo se trate de ASCII de 7 bits). En Python 3, las instancias de bytes y str nunca son equivalentes, ni siquiera la cadena vacía, por lo que debe ser más deliberado sobre los tipos de secuencias de caracteres que está pasando.
El segundo problema es que en Python 3, las operaciones que implican manejadores de archivos tienen por defecto la codificación UTF-8. En Pyhton 2, las operaciones de archivo están predeterminadas en codificación binaria. Esto causa fallas sorprendentes, especialmente para programadores acostumbrados a Python 2.
Por ejemplo, supongamos que quieres escribir algunos datos binarios aleatorios en un archivo. En Python 2, esto funciona. En Python 3, se rompe.
1 2 3 4 5 | with open('/tmp/random.bin', 'w') as f: f.write(os.urandom(10)) >>> TypeError: must be str, not bytes |
La causa de esta excepción es el nuevo argumento de codificación para abrir que se agregó en Python 3. Este parámetro tiene por defecto ‘utf-8’. Eso hace que las operaciones de lectura y escritura en los manejadores de archivos esperen instancias str que contengan caracteres Unicode en lugar de instancias de bytes que contengan datos binarios.
Para que esto funcione correctamente, debe indicar que los datos se están abriendo en el modo binario de escritura (‘wb’) en lugar de escribir el modo de caracteres (‘w’). Aquí, utilizo abrir de una manera que funciona correctamente en Python 2 y Python 3:
1 2 | with open('/tmp/random.bin', 'wb') as f: f.write(os.urandom(10)) |
Este problema también existe para leer datos de archivos. La solución es la misma: indique el modo binario usando ‘rb’ en vez de ‘r’ al abrir un archivo.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]
Puntos a recordar
- En Python 3, bytes contiene secuencias de 8-bits, str contiene secuencias de caracteres Unicode. Las instancias de bytes y str no se pueden utilizar juntas con los operadores.
- En Python 2, str contiene secuencias de 8-bits, unicode contiene secuencia de caracteres Unicode. Los tipos str y unicode se pueden utilizar juntos con los operadores si str solo contiene caracteres ASCII de 7-bits.
- Use funciones auxiliares para asegurarse de que las entradas en las que opera son del tipo de secuencia de caracteres que espera (valores de 8 bits, caracteres codificados UTF-8, caracteres Unicode, etc).
- Si desea leer o escribir datos binarios desde/hacia un archivo, siempre abra el archivo utilizando el modo binario (como ‘rb’ o ‘wb’).
[/vc_column_text][/vc_column][/vc_row]
