Processar sequências de escape em uma string em Python

Às vezes, quando recebo a entrada de um arquivo ou do usuário, recebo uma string com sequências de escape. Gostaria de processar as sequências de escape da mesma forma que o Python processa as sequências de escape em literais de string .

Por exemplo, digamos que myStringseja definido como:

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

Quero uma função (vou chamá-la process) que faça isso:

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

É importante que a função possa processar todas as sequências de escape em Python (listadas em uma tabela no link acima).

O Python tem uma função para fazer isso?

A coisa correta a fazer é usar o código 'string-escape' para decodificar a string.

>>> 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

Não use o AST ou eval. Usar os codecs de string é muito mais seguro.

unicode_escape não funciona em geral

Acontece que a solução string_escapeou unicode_escapenão funciona em geral - particularmente, não funciona na presença de Unicode real.

Se você puder ter certeza de que todos os caracteres não ASCII terão escape (e lembre-se, qualquer coisa além dos primeiros 128 caracteres não são ASCII), unicode_escapefará a coisa certa para você. Mas se já houver caracteres não-ASCII literais em sua string, as coisas darão errado.

unicode_escapeé fundamentalmente projetado para converter bytes em texto Unicode. Mas em muitos lugares - por exemplo, código-fonte Python - os dados-fonte já são texto Unicode.

A única maneira de funcionar corretamente é codificar o texto em bytes primeiro. UTF-8 é a codificação sensata para todo o texto, então deve funcionar, certo?

Os exemplos a seguir estão em Python 3, de modo que os literais de string são mais limpos, mas o mesmo problema existe com manifestações ligeiramente diferentes em Python 2 e 3.

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

Bem, isso está errado.

A nova maneira recomendada de usar codecs que decodificam texto em texto é chamar codecs.decodediretamente. Isso ajuda?

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

De modo nenhum. (Além disso, o acima é um UnicodeError no Python 2.)

O unicode_escapecodec, apesar do nome, supõe que todos os bytes não ASCII estão na codificação Latin-1 (ISO-8859-1). Então você teria que fazer assim:

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

Mas isso é terrível. Isso limita você aos 256 caracteres Latin-1, como se o Unicode nunca tivesse sido 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)

Adicionando uma expressão regular para resolver o problema

(Surpreendentemente, não temos agora dois problemas.)

O que precisamos fazer é apenas aplicar o unicode_escapedecodificador a coisas que temos certeza que são texto ASCII. Em particular, podemos ter certeza de aplicá-lo apenas a sequências de escape válidas do Python, que são garantidamente texto ASCII.

O plano é encontrar sequências de escape usando uma expressão regular e usar uma função como o argumento re.subpara substituí-las por seu valor sem 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)

E com isso:

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

A resposta realmente correta e 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

Detalhes sobre codecs.escape_decode:

• codecs.escape_decode é um decodificador de bytes para bytes
• codecs.escape_decodedecodifica sequências de escape ascii, como: b"\\n"-> b"\n", b"\\xce"-> b"\xce".
• codecs.escape_decode não se importa ou precisa saber sobre a codificação do objeto de byte, mas a codificação dos bytes de escape deve corresponder à codificação do resto do objeto.

Fundo:

• @rspeer está correto: unicode_escapeé a solução incorreta para python3. Isso ocorre porque unicode_escapedecodifica bytes de escape e, em seguida, decodifica bytes para string Unicode, mas não recebe nenhuma informação sobre qual codec usar para a segunda operação.
• @Jerub está correto: evite o AST ou eval.
• Eu descobri codecs.escape_decodepela primeira vez com esta resposta para "como faço para .decode ('string-escape') em Python3?" . Como afirma essa resposta, essa função não está documentada atualmente para Python 3.

A ast.literal_evalfunção chega perto, mas espera que a string seja devidamente citada primeiro.

É claro que a interpretação do Python dos escapes de barra invertida depende de como a string está entre aspas ( ""vs r""vs u"", aspas triplas, etc), então você pode querer envolver a entrada do usuário em aspas adequadas e passar para literal_eval. Colocá-lo entre aspas também impedirá o literal_evalretorno de um número, tupla, dicionário, etc.

As coisas ainda podem ficar complicadas se o usuário digitar aspas sem aspas do tipo que você pretende envolver na string.

Esta é uma maneira ruim de fazer isso, mas funcionou para mim ao tentar interpretar octais escapados passados ​​em um argumento de string.

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

Vale a pena mencionar que há uma diferença entre eval e ast.literal_eval (eval sendo muito mais inseguro). Consulte Usando eval () do python vs. ast.literal_eval ()?

O código abaixo deve funcionar para \ n é necessário para ser exibido na string.

import string

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