Trabajar con el modulo re() de Python

logo python

Python tiene un módulo llamado re() para trabajar con las RegEx. Trabajar con el modulo re(), no es complejo.

Pueden ver un articulo que escribí hace un tiempo, sobre ello.

En Python, existen herramientas especificas, que funcionan como auxiliares y modificadores para el trabajo con las RegEx.

Me refiero tanto al uso del modulo re() , como al empleo de r o R antes de una RegEx como prefijo.

Cuando se escribe una expresión regular y se coloca el \ delante de ella, este equivale a un escape del carácter que le sigue, de este modo \n o \r provocará que el lenguaje escape estos caracteres; sin embargo cuando colocamos r delante, estos serán considerados y tratados como un carácter normal.

La sintaxis para esto, es por ejemplo r’[\n\r]’

Veamos como usar re()

re.findall()

Nos devuelve una lista de todas las cadenas que contienen la coincidencias

import re

cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\D+'
buscamos todos aquellos caracteres que no sean digitos con re.findall()
coincid = re.findall(pattern, cadena)
coincid
ouput:['Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.']

pattern = '\d+'
output:[]

re.split()

Separa las cadenas donde existen las coincidencias y retorna una lista de  cadenas donde hay coincidencias.

pattern = '\D+'
cadena = 'amigos 12345 45:67'
#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output: ['', '12345', '45', '67']
pattern = '\d+'
output:cadena = 'amigos 12345 45:67'

#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output:['amigos ', ' ', ':', '']

Como se ve en el ejemplo se puede usar maxsplit para determinar el numero máximo de separaciones que deseamos que ocurran.

#utilizamos maxsplit 1
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 1)
coincid
output:['', '12345 45:67']

#utilizamos maxsplit 3
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 3)
coincid
output:['', '12345', '45', '67']

Re.sub()

Devuelve la cadena donde existe coincidencia y reemplaza el contenido con el valor de la variable replace.

#sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, cadena)
nueva_cadena
out:'Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.'

Podemos contar  utilizando count() como cuarto parámetro, para determinar cuántos reemplazosharenmos.

Si omitiéramos el valor sub(), reemplazará todas las coincidencias.

#añadiendo count() como parametro
string = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, string, 5)
nueva_cadena
output:'Cuanto,hice,hasta,hoy,,y,haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'

re.subn()

Es similar a sub(), pero devuelve una tupla con contiene la nueva cadena y la cantidad de sustitucones realizadas.

#empleamos re.subn(), para obgener una tupla que contiene la nueva cadena y la cantidad de substituciones realizadas
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.subn(pattern, replace, cadena)
nueva_cadena
output: ('Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.', 44)

re.search()

Se emplea para la búsqueda de coincidencias directamente, utilizando dos argumentos, el patrón a buscar y la cadena donde buscarlo.

Su resultado es un objeto match, si no hubiera coincidencia retornaría None.

#empleamos re.search(), para hallar la subcadena silencio
sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('silencio',cadena)
busqueda
output:<re.Match object; span=(47, 55), match='silencio'>

El objeto que nos devuelve la variable búsqueda es del tipo match, con el cual podemos hacer también varias operaciones.

#operando con el resultado, ahora buscamos silencio al final de una cadena y hacemos algo
adena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('\Zsilencio',cadena)
if busqueda:
pass
else:
print('no se halló nada')
output:no se halló nada

Con re(), podemos buscar utilizando re.match(), que  recibe dos parámetros: los patrones que buscamos y el texto donde los buscamos.

match.group()

Nos permite agrupar los resultados en subcadenas.

#buscamos con match.group() el grupo de letras seguidas por una r
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '(a|e|i)r'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output:ar

#buscamos un grupo que tiene dos digitos separados por un espacio de una cadena no digital de seis caracteres
cadena = '234 567896 10 acceso dni color de los ojos'
pattern = '(\d{2}) (\D{6})'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output: 10 acceso

Podemos condicionar cuantas subcadenas queremos y sus posiciones

#imprimiendo solo el primer subgrupo
match = re.search(pattern, cadena)
if match:
print(match.group(1))
else:
print('no se halló nada')
output:10

#obteniendo la posicion donde comienza el grupo, donde termina y una tupla con ambos valores
match = re.search(pattern, cadena)
if match:
print(match.start(), match.end(), match.span())
else:
print('no se halló nada')
output:11 20 (11, 20)

Match.string

Nos devuelve la cadena.

match.string
output:'234 567896 10 acceso dni color de los ojos'

«En total oscuridad cualquier cosa, puede ser luz»

Expresiones regulares. RegEx

Aprender sobre manejar expresiones regulares fue de las primeras cosas a las que tuve que enfrentarme, casi desde cero.

Les dejo una explicación de la esencia de este tema, que espero que a más de uno le sirva de ayuda.

Una expresión regular (RegEx) es una secuencia de caracteres que define un patrón de búsqueda.

En su modo mas simple digamos que una expresión regular del tipo :

^t…o$

Corresponde a cualquier palabra de cinco letras que comience con t y termine en o, como «tanto», «tonto», «tengo», «trillo», o «talio» por ejemplo, entre muchas otras .

En cambio, palabras como «tampoco», «tantísimo», o «tranco», por ejemplo no cumplirían los requisitos para coincidir , con esa búsqueda.

Las expresiones regulares, conocidas como RegEx, es una herramienta medianamente compleja, que nos permite identificar caracteres específicos de texto dentro de cadenas, para operar con ellos.

Conocer todas las expresiones regulares, es algo que lleva tiempo y practica, pero intentaré explicarlo sucintamente.

Metacaracteres

La lista de abajo muestra los metacaractéres, estos tienen un significado especial dentro de las RegEx

[] . ^ $ * + ? {} () \ |

Veamos cada uno

Los corchetes []

Los caracteres individuales que queremos encontrar se encierran entre [] .
por ejemplo [abc], devolverá coincidencias, con cualquier cadena que contenga esas tres letras como “a”, “a veces”,“obcecado”

A esta búsqueda se puede añadir otros elementos para hacerla mas especifica por ejemplo :

[a-d] es lo mismo que  [abcd].

[1-4] es lo mismo [1234].

[0-39] es lo mismo [01239]

Aunque en los dos primeros casos muestra intervalo, en el último indica intervalo igualmente, pero no así para el ultimo dígito que se indica específicamente.

 Contrario a esto, el símbolo ^ , cuando se inserta entre los corchetes al inicio de la expresión, indica excepción por ejemplo [^abc], nos dice que cualquier carácter excepto 'a' o 'b‘ o 'c

Por tanto  si escribimos por ejemplo [^a-z], estamos hablando de cualquier carácter  que no se encuentre en el rango de la ‘a’ a la ‘z’ .

[^0-9] indica cualquier carácter menos los dígitos, …

y [^123], cualquier carácter excepto 1 ó 2 ó 3.

El punto .  

El punto equivale a cualquier carácter individual, menos un salto de línea '\n'.

Por ejemplo la expresión, encontrará coincidencias con cualquier cadena que contenga como mínimo tres caracteres. Una cadena de tres caracteres devolverá un coincidencia, al igual que una de 5, pero una de seis encontrará dos y una de 9, tres

Intercalado o caret (inglés) ^

Cuando se coloca solo, se utiliza para conocer si una cadena comienza con determinado carácter.

Por ejemplo ^b, hallara coincidencias en ‘brillo’ y ‘bandera’, pero no en ‘abanderado’  

Símbolo  dollar $

Se emplea para saber si una cadena termina en un determinado carácter.

$r, buscara coincidencias para cadenas que terminen en ‘r’

Símbolo asterisco *, símbolo suma + y símbolo de interrogación ?

Estos tres signos buscan coincidencias en cadenas, siguiendo una lógica de unión entre los caracteres.

La diferencia de su comportamiento esta en que * busca 0 o mas coincidencias, mientras + busca una o más y   '?' busca 0 o una

Si tomamos como  expresión búsqueda , «te*n»,  esta nos dice que buscamos cualquier cadena donde no este completa, o este esta condición  que exista una»t» ,  y una «n», y si existe una «e», este obligatoriamente seguida de la «n”.

Hallaremos  coincidencias en «tn», «ten», «teen», y «manten», pero no en «tean», porque la «e» no va seguida inmediatamente de la «n»,

La expresión te+n, sigue la misma lógica pero espera encontrar una o más coincidencias, por tanto tn, no devolverá coincidencias, porque no hay una «e», ni tampoco «tean», porque la «e» no va seguida de la «n».

Si utilizamos con esta mismo texto de búsqueda, pero sustituyendo la RegEx por un signo de interrogación te?n, este busca 0 o una coincidencia, en tn hallará una, al igual que en «ten» y «manten».

No sucederá lo mismo  en «teen» o «tean», primero porque en «teen» no existe más de un carácter e y en «tean», la e no va seguida de la n.

Llaves {}

Las llaves {}, se emplean para indicar un rango, de ocurrencia, donde el primer elemento es el mínimos esperado y el segundo, el máximo.

O se n{x,y}, espera que exista como mínimo una ocurrencia x y cómo máximo una y del patrón n.

Si tomamos como patrón de búsqueda a {1,9}, estamos esperando hallar como mínimo una a y como máximo 9.

Un ejemplo común, es que un patrón como [0-9]{3, 6}, buscara al menos tres dígitos seguidos y como máximo 6.

Por tanto hallara coincidencias en las siguientes cadenas 1234, 234567, 333; sin embargo no hallará en 22, 3456878,  o 1

Barra vertical |

Esta es más conocida de otros lenguajes de progrmacion y se usa para alternar entre valores.

De este modo a|b, busca a o b y en una cadena como «babilonia», hallará cuatro coincidencias

Parentesis ()

Se emplean para agrupar varios patrones.

Un agrupamiento de (a|e|i)r, buscará coincidencias de cualquier subcadena , a, e i que vayan seguidas inmediatamente del carácter r.

De este modo hallara ocurrencias en ‘balar’, ‘correr’, ‘reir’, ‘harto’, verde, ‘irina’, ‘subir’ o ‘bajar’, pero no en ‘a’, ‘ r’, ‘eleonor’, u ‘orina’.

Backslah \

Se emplea como señal de escape de varios caracteres y esto incluye también a los meta caracteres.
Por ejemplo si lo usamos antes de un metacaracter alterará o anulará su significado.

Si escribimos \$n,  se encontraran coincidencias, en aquellos casos  donde después del símbolo de dólar aparezca una ‘n‘,  y dejará de verlo como una expresión regular que indica final de la cadena.

Backslah también se utiliza para indicar otras cuestiones, usándolo con otros caracteres. Veamos

\A encuentra coincidencias con caracteres específicos que se encuentran al comienzo de una cadena.\Aes, hallará ocurrencias en cadenas que comiencen con es.

\b encuentra coincidencias con caracteres específicos al comienzo o terminación de una palabra. \bfía, coincidirá con «ecografía» y «con fiabilidad», y no con «confiabilidad»

\B encuentra coincidencias donde no se cumple la condición o sea, que no aparezcan al inicio o comienzo de la palabra los caracteres dados. Es la oposición al \b anterior asi que ahora si coincidirá con confiabilidad

\d halla coincidencias con cualquier dígito decimal. Esta expresión es lo mismo que escribir [0-9].

\D, se opone al anterior y por tanto buscará concurrencias de cualquier elemento que no sea un dígito

\s coincide con cualquier cadena, que posea un espacio en blanco.

\S coincide con cualquier cadena, donde no exista un espacio en blanco.

\w hallará coincidencias con cualquier cadena, donde existan caractéres alfanuméricos (o sea números y letras, incluidos _). Sería lo mismo que escribir [a-zA-Z0-9_].

\W busca cualquier carácter que no sea alfanumérico. Tendriamos el mismo resultado que si escribimos [^a-zA-Z0-9_]

\Z, coincidirá con caracteres específicos al final de una cadena. \Zión hallará una ocurrencia en ‘sanción’.

De forma bastante resumida,  estas son las expresiones regulares. Existen múltiples herramientas en internet, para agilizar el trabajo con ellas de forma online, y que pueden ayudarte a construirlas de manera efectiva.

«En total oscuridad cualquier cosa, puede ser luz»

Translate »