open - Python: conversión de ISO-8859-1/latin1 a UTF-8

python utf8 header

Question

Tengo esta cadena que ha sido decodificada desde Quoted-printable hasta ISO-8859-1 con el módulo de correo electrónico. Esto me da cadenas como "/ xC4pple" que correspondería a "Äpple" (Apple en sueco). Sin embargo, no puedo convertir esas cadenas a UTF-8.

>>> apple = "/xC4pple"
>>> apple
''/xc4pple''
>>> apple.encode("UTF-8")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: ''ascii'' codec can''t decode byte 0xc4 in position 0: ordinal not in     range(128)

¿Que debería hacer?

Answer 1

concept = concept.encode (''ascii'', ''ignore'') concept = MySQLdb.escape_string (concept.decode (''latin1''). encode (''utf8''). rstrip ())

Hago esto, no estoy seguro si ese es un buen enfoque pero funciona siempre !!

Answer 2

Decode a Unicode, codifique los resultados a UTF8.

apple.decode (''latin1''). encode (''utf8'')

Answer 3

Este es un problema común, así que aquí hay una ilustración relativamente completa.

Para cadenas no unicode (es decir, aquellas sin el prefijo u como u''/xc4pple'' ), se debe decodificar desde la codificación nativa ( iso8859-1 / latin1 , a menos que se modifique con la enigmática función sys.setdefaultencoding ) a unicode , luego codificar a un juego de caracteres que puede mostrar los caracteres que deseas, en este caso recomendaría UTF-8 .

Primero, aquí hay una útil función de utilidad que ayudará a iluminar los patrones de la cadena de Python 2.7 y Unicode:

>>> def tell_me_about(s): return (type(s), s)

Una cadena simple

>>> v = "/xC4pple" # iso-8859-1 aka latin1 encoded string

>>> tell_me_about(v)
(<type ''str''>, ''/xc4pple'')

>>> v
''/xc4pple''        # representation in memory

>>> print v
?pple             # map the iso-8859-1 in-memory to iso-8859-1 chars
                  # note that ''/xc4'' has no representation in iso-8859-1, 
                  # so is printed as "?".

Decodificando una cadena iso8859-1 - convierte una cadena simple a unicode

>>> uv = v.decode("iso-8859-1")
>>> uv
u''/xc4pple''       # decoding iso-8859-1 becomes unicode, in memory

>>> tell_me_about(uv)
(<type ''unicode''>, u''/xc4pple'')

>>> print v.decode("iso-8859-1")
Äpple             # convert unicode to the default character set
                  # (utf-8, based on sys.stdout.encoding)

>>> v.decode(''iso-8859-1'') == u''/xc4pple''
True              # one could have just used a unicode representation 
                  # from the start

Un poco más de ilustración - con "Ä"

>>> u"Ä" == u"/xc4"
True              # the native unicode char and escaped versions are the same

>>> "Ä" == u"/xc4"  
False             # the native unicode char is ''/xc3/x84'' in latin1

>>> "Ä".decode(''utf8'') == u"/xc4"
True              # one can decode the string to get unicode

>>> "Ä" == "/xc4"
False             # the native character and the escaped string are
                  # of course not equal (''/xc3/x84'' != ''/xc4'').

Codificando a UTF

>>> u8 = v.decode("iso-8859-1").encode("utf-8")
>>> u8
''/xc3/x84pple''    # convert iso-8859-1 to unicode to utf-8

>>> tell_me_about(u8)
(<type ''str''>, ''/xc3/x84pple'')

>>> u16 = v.decode(''iso-8859-1'').encode(''utf-16'')
>>> tell_me_about(u16)
(<type ''str''>, ''/xff/xfe/xc4/x00p/x00p/x00l/x00e/x00'')

>>> tell_me_about(u8.decode(''utf8''))
(<type ''unicode''>, u''/xc4pple'')

>>> tell_me_about(u16.decode(''utf16''))
(<type ''unicode''>, u''/xc4pple'')

Relación entre Unicode y UTF y latin1

>>> print u8
Äpple             # printing utf-8 - because of the encoding we now know
                  # how to print the characters

>>> print u8.decode(''utf-8'') # printing unicode
Äpple

>>> print u16     # printing ''bytes'' of u16
���pple

>>> print u16.decode(''utf16'')
Äpple             # printing unicode

>>> v == u8
False             # v is a iso8859-1 string; u8 is a utf-8 string

>>> v.decode(''iso8859-1'') == u8
False             # v.decode(...) returns unicode

>>> u8.decode(''utf-8'') == v.decode(''latin1'') == u16.decode(''utf-16'')
True              # all decode to the same unicode memory representation
                  # (latin1 is iso-8859-1)

Excepciones Unicode

 >>> u8.encode(''iso8859-1'')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: ''ascii'' codec can''t decode byte 0xc3 in position 0:
  ordinal not in range(128)

>>> u16.encode(''iso8859-1'')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: ''ascii'' codec can''t decode byte 0xff in position 0:
  ordinal not in range(128)

>>> v.encode(''iso8859-1'')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: ''ascii'' codec can''t decode byte 0xc4 in position 0:
  ordinal not in range(128)

Uno podría evitar esto convirtiendo de la codificación específica (latin-1, utf8, utf16) a unicode, por ejemplo u8.decode(''utf8'').encode(''latin1'') .

Entonces, quizás uno podría dibujar los siguientes principios y generalizaciones:

• un tipo str es un conjunto de bytes, que puede tener una de varias codificaciones, como Latin-1, UTF-8 y UTF-16.
• un tipo unicode es un conjunto de bytes que se puede convertir a cualquier número de codificaciones, más comúnmente UTF-8 y latin-1 (iso8859-1)
• el comando de print tiene su propia lógica de codificación , se establece en sys.stdout.encoding y por defecto en UTF-8
• Uno debe decodificar un str para unicode antes de convertir a otra codificación.

Por supuesto, todo esto cambia en Python 3.x.

Espero que sea esclarecedor.

Otras lecturas

• Personajes vs. Bytes , por Tim Bray.

Y las demostraciones muy ilustrativas de Armin Ronacher:

• La guía actualizada de Unicode en Python (2 de julio de 2013)
• Más sobre Unicode en Python 2 y 3 (5 de enero de 2014)
• UCS vs UTF-8 como codificación de cadena interna (9 de enero de 2014)
• Todo lo que no quería saber sobre Unicode en Python 3 (12 de mayo de 2014)

Answer 4

Intente decodificarlo primero, luego codifique:

apple.decode(''iso-8859-1'').encode(''utf8'')

Answer 5

Para Python 3:

bytes(apple,''iso-8859-1'').decode(''utf-8'')

Lo usé para un texto incorrectamente codificado como iso-8859-1 (que muestra palabras como VeÅ / x99ejnà © ) en lugar de utf-8. Este código produce la versión correcta Veřejné .