separar - Secuencias de escape de proceso en una cadena en Python

python separar string por caracter

Question

A veces, cuando recibo información de un archivo o del usuario, aparece 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 literales de cadenas .

Por ejemplo, supongamos que myString se define como:

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

Quiero una función (lo llamaré process ) que hace 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 anterior).

¿Tiene Python una función para hacer esto?

Answer 1

unicode_escape no funciona en general

Resulta que la solución string_escape o unicode_escape no funciona en general, particularmente, no funciona en presencia de Unicode real.

Si puede estar seguro de que se unicode_escape cualquier carácter que no sea ASCII (y recuerde que cualquier cosa que esté más allá de los primeros 128 caracteres no es ASCII), unicode_escape hará lo correcto para usted. Pero si ya hay algunos caracteres literales que no son ASCII en su cadena, las cosas saldrán mal.

unicode_escape está diseñado fundamentalmente para convertir bytes en texto Unicode. Pero en muchos lugares, por ejemplo, el código fuente de Python, la fuente de datos ya es 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, por lo 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 el mismo problema existe 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 usar códecs que decodifican texto en texto es llamar codecs.decode directamente. ¿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 códec unicode_escape , a pesar de su nombre, da por hecho 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 te limita a los 256 caracteres latinos-1, ¡como si nunca hubiera sido inventado Unicode!

>>> 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 decodificador unicode_escape a cosas que estamos seguros serán de texto ASCII. En particular, podemos asegurarnos de aplicarlo únicamente a las secuencias de escape de Python válidas, que se garantiza que son texto ASCII.

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

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

Answer 2

Debajo del código debería funcionar / n para mostrarse 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)

Answer 3

La función ast.literal_eval se acerca, pero esperará que la cadena se ast.literal_eval correctamente primero.

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

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

Answer 4

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_decode decodifica secuencias de escape ascii, como: b"//n" -> b"/n" , b"//xce" -> b"/xce" .
• codecs.escape_decode no se preocupa o necesita saber sobre la codificación del objeto byte, pero la codificación de los bytes escapados debe coincidir con la codificación del resto del objeto.

Fondo:

• @rspeer es correcto: unicode_escape es la solución incorrecta para python3. Esto se debe a que unicode_escape decodifica los bytes escapados, luego decodifica los bytes a cadena unicode, pero no recibe información con respecto a qué códec usar para la segunda operación.
• @Jerub es correcto: evita el AST o eval.
• Primero descubrí codecs.escape_decode 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.

Answer 5

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 cuerda es mucho más seguro.

Answer 6

Si confías en la fuente de los datos, solo dales una bofetada y evalúa ()?

>>> myString = ''spam//neggs''
>>> print eval(''"'' + myString.replace(''"'','''') + ''"'')
spam
eggs

PD. se agregó una contramedida de código malicioso-exec: ahora se quitará todo " antes de evaluar"