Procesar secuencias de escape en una cadena en Python

A veces, cuando obtengo información de un archivo o del usuario, obtengo una cadena con secuencias de escape. Me gustaría procesar las secuencias de escape de la misma manera que Python procesa las secuencias de escape en cadenas literales .

Por ejemplo, digamos que myStringse define como:

>>> myString = "spam\\neggs"
>>> print(myString)
spam\neggs

Quiero una función (la llamaré process) que haga esto:

>>> print(process(myString))
spam
eggs

Es importante que la función pueda procesar todas las secuencias de escape en Python (enumeradas en una tabla en el enlace de arriba).

¿Python tiene una función para hacer esto?

Lo correcto es usar el código 'string-escape' para decodificar la cadena.

>>> myString = "spam\\neggs"
>>> decoded_string = bytes(myString, "utf-8").decode("unicode_escape") # python3 
>>> decoded_string = myString.decode('string_escape') # python2
>>> print(decoded_string)
spam
eggs

No use AST o eval. Usar los códecs de cadena es mucho más seguro.

unicode_escape no funciona en general

Resulta que la solución string_escapeo unicode_escapeno funciona en general; en particular, no funciona en presencia de Unicode real.

Si puede estar seguro de que todos los caracteres que no sean ASCII se escaparán (y recuerde, cualquier cosa más allá de los primeros 128 caracteres no es ASCII), unicode_escapehará lo correcto por usted. Pero si ya hay caracteres literales no ASCII en su cadena, las cosas saldrán mal.

unicode_escapeestá diseñado fundamentalmente para convertir bytes en texto Unicode. Pero en muchos lugares, por ejemplo, el código fuente de Python, los datos de origen ya son texto Unicode.

La única forma en que esto puede funcionar correctamente es si primero codifica el texto en bytes. UTF-8 es la codificación sensata para todo el texto, así que debería funcionar, ¿verdad?

Los siguientes ejemplos están en Python 3, por lo que los literales de cadena son más limpios, pero existe el mismo problema con manifestaciones ligeramente diferentes en Python 2 y 3.

>>> s = 'naïve \\t test'
>>> print(s.encode('utf-8').decode('unicode_escape'))
naïve   test

Bueno, eso está mal.

La nueva forma recomendada de utilizar códecs que decodifican texto en texto es llamar codecs.decodedirectamente. ¿Eso ayuda?

>>> import codecs
>>> print(codecs.decode(s, 'unicode_escape'))
naïve   test

De ningún modo. (Además, lo anterior es un UnicodeError en Python 2.)

El unicode_escapecódec, a pesar de su nombre, asume que todos los bytes que no son ASCII están en la codificación Latin-1 (ISO-8859-1). Entonces tendrías que hacerlo así:

>>> print(s.encode('latin-1').decode('unicode_escape'))
naïve    test

Pero eso es terrible. Esto lo limita a los 256 caracteres Latin-1, ¡como si Unicode nunca se hubiera inventado!

>>> print('Ernő \\t Rubik'.encode('latin-1').decode('unicode_escape'))
UnicodeEncodeError: 'latin-1' codec can't encode character '\u0151'
in position 3: ordinal not in range(256)

Agregar una expresión regular para resolver el problema

(Sorprendentemente, ahora no tenemos dos problemas).

Lo que tenemos que hacer es aplicar el unicode_escapedecodificador solo a cosas que estamos seguros de que serán texto ASCII. En particular, podemos asegurarnos de aplicarlo solo a secuencias de escape de Python válidas, que están garantizadas como texto ASCII.

El plan es que encontraremos secuencias de escape usando una expresión regular y usaremos una función como argumento re.subpara reemplazarlas con su valor sin escape.

import re
import codecs

ESCAPE_SEQUENCE_RE = re.compile(r'''
    ( \\U........      # 8-digit hex escapes
    | \\u....          # 4-digit hex escapes
    | \\x..            # 2-digit hex escapes
    | \\[0-7]{1,3}     # Octal escapes
    | \\N\{[^}]+\}     # Unicode characters by name
    | \\[\\'"abfnrtv]  # Single-character escapes
    )''', re.UNICODE | re.VERBOSE)

def decode_escapes(s):
    def decode_match(match):
        return codecs.decode(match.group(0), 'unicode-escape')

    return ESCAPE_SEQUENCE_RE.sub(decode_match, s)

Y con eso:

>>> print(decode_escapes('Ernő \\t Rubik'))
Ernő     Rubik

La respuesta realmente correcta y conveniente para Python 3:

>>> import codecs
>>> myString = "spam\\neggs"
>>> print(codecs.escape_decode(bytes(myString, "utf-8"))[0].decode("utf-8"))
spam
eggs
>>> myString = "naïve \\t test"
>>> print(codecs.escape_decode(bytes(myString, "utf-8"))[0].decode("utf-8"))
naïve    test

Detalles sobre codecs.escape_decode:

• codecs.escape_decode es un decodificador de bytes a bytes
• codecs.escape_decodedecodifica secuencias de escape ascii, como: b"\\n"-> b"\n", b"\\xce"-> b"\xce".
• codecs.escape_decode no le importa ni necesita saber acerca de la codificación del objeto byte, pero la codificación de los bytes escapados debe coincidir con la codificación del resto del objeto.

Antecedentes:

• @rspeer es correcto: unicode_escapees la solución incorrecta para python3. Esto se debe a que unicode_escapedecodifica los bytes de escape, luego decodifica los bytes en una cadena Unicode, pero no recibe información sobre qué códec usar para la segunda operación.
• @Jerub es correcto: evite el AST o eval.
• Descubrí por primera vez a codecs.escape_decodepartir de esta respuesta a "¿cómo puedo .decode ('string-escape') en Python3?" . Como dice esa respuesta, esa función actualmente no está documentada para Python 3.

La ast.literal_evalfunción se acerca, pero espera que la cadena se cite correctamente primero.

Por supuesto, la interpretación de Python de los escapes de barra invertida depende de cómo se cite la cadena ( ""vs r""vs u"", comillas triples, etc.) por lo que es posible que desee envolver la entrada del usuario entre comillas adecuadas y pasar a literal_eval. Envolverlo entre comillas también evitará que se literal_evaldevuelva un número, tupla, diccionario, etc.

Las cosas aún pueden complicarse si el usuario escribe comillas sin comillas del tipo que pretende envolver alrededor de la cadena.

Esta es una mala forma de hacerlo, pero funcionó para mí cuando intentaba interpretar octals escapados pasados ​​en un argumento de cadena.

input_string = eval('b"' + sys.argv[1] + '"')

Vale la pena mencionar que hay una diferencia entre eval y ast.literal_eval (eval es mucho más inseguro). Ver ¿ Usar eval () de python frente a ast.literal_eval ()?

El siguiente código debería funcionar para \ n es necesario que se muestre en la cadena.

import string

our_str = 'The String is \\n, \\n and \\n!'
new_str = string.replace(our_str, '/\\n', '/\n', 1)
print(new_str)