regulares - Python Regular Expressions para implementar el descamado de cadenas

re.sub python ejemplos

Question

Estoy intentando implementar unescaping de cadenas con Python Regex y Back References, y no parece querer funcionar muy bien. Estoy seguro de que es algo que estoy haciendo mal, pero no puedo entender qué ...

>>> import re
>>> mystring = r"This is /n a test /r"
>>> p = re.compile( "////(//S)" )
>>> p.sub( "//1", mystring )
''This is n a test r''
>>> p.sub( "//////1", mystring )
''This is //n a test //r''
>>> p.sub( "////1", mystring )
''This is //1 a test //1''

Me gustaría reemplazar // [char] con / [char], pero las referencias en Python no parecen seguir las mismas reglas que en cualquier otra implementación que haya usado alguna vez. ¿Alguien podría arrojar algo de luz?

Answer 1

¿No es eso lo que hace el segundo ejemplo de Anders?

En 2.5 también hay una codificación de string-escape que puede aplicar:

>>> mystring = r"This is /n a test /r"
>>> mystring.decode(''string-escape'')
''This is /n a test /r''
>>> print mystring.decode(''string-escape'')
This is
a test
>>> 

Answer 2

Bueno, creo que es posible que te hayas perdido o haya contado mal las barras invertidas ...

"//n" == r"/n"
>>> import re
>>> mystring = r"This is //n a test //r"
>>> p = re.compile( r"[//][//](.)" )
>>> print p.sub( r"///1", mystring )
This is /n a test /r
>>>

Lo cual, si entendí, es lo que se solicitó.

Sospecho que la solicitud más común es esta:

>>> d = {''n'':''/n'', ''r'':''/r'', ''f'':''/f''}
>>> p = re.compile(r"[//]([nrfv])")
>>> print p.sub(lambda mo: d[mo.group(1)], mystring)
This is /
a test /
>>>

El estudiante interesado también debería leer Reflexiones sobre Confianza en Confianza de Ken Thompson " , donde nuestro héroe usa un ejemplo similar para explicar los peligros de compiladores confiables que usted mismo no ha arrancado del código máquina.

Answer 3

Estás siendo engañado por la representación de Python de la cadena de resultados. La expresión de Python:

''This is //n a test //r''

representa la cadena

This is /n a test /r

que es, creo, lo que querías Intente agregar ''print'' delante de cada una de sus llamadas p.sub () para imprimir la cadena real devuelta en lugar de una representación de Python de la cadena.

>>> mystring = r"This is /n a test /r"
>>> mystring
''This is //n a test //r''
>>> print mystring
This is /n a test /r

Answer 4

La idea es que leeré en una cadena escapada y la desenterraré (una característica notablemente ausente de Python, para la cual no deberías necesitar recurrir a expresiones regulares en primer lugar). Lamentablemente, no estoy siendo engañado por las barras invertidas ...

Otro ejemplo ilustrativo:

>>> mystring = r"This is /n ridiculous"
>>> print mystring
This is /n ridiculous
>>> p = re.compile( r"//(/S)" )
>>> print p.sub( ''bloody'', mystring )
This is bloody ridiculous
>>> print p.sub( r''/1'', mystring )
This is n ridiculous
>>> print p.sub( r''//1'', mystring )
This is /1 ridiculous
>>> print p.sub( r''///1'', mystring )
This is /n ridiculous

Lo que me gustaría que imprima es

This is
ridiculous

Answer 5

Marca; su segundo ejemplo requiere que todos los caracteres escapados se arrojen inicialmente a una matriz, lo que genera un KeyError si la secuencia de escape no está en la matriz. Morirá en cualquier cosa que no sean los tres caracteres proporcionados (give / va try), y enumerar todas las posibles secuencias de escape cada vez que quiera desentrañar una cadena (o mantener una matriz global) es una solución realmente mala. De forma análoga a PHP, eso es usar preg_replace_callback() con un lambda en lugar de preg_replace() , lo cual es completamente innecesario en esta situación.

Lo siento si me estoy volviendo loco, estoy completamente frustrado con Python. Esto es compatible con cualquier otro motor de expresión regular que haya usado alguna vez, y no puedo entender por qué esto no funcionaría.

Gracias por responder; la función string.decode(''string-escape'') es precisamente lo que estaba buscando inicialmente. Si alguien tiene una solución general al problema de retro-expresión regex, no dude en publicarlo y lo aceptaré también como una respuesta.