Expresiones regulares¶

El módulo re permite trabajar con expresiones regulares.

Expresión regular¶

Una expresión regular (también conocida como «regex» o «regexp» por su contracción anglosajona «reg-ular exp-ression») es una cadena de texto que conforma un patrón de búsqueda. Se utiliza principalmente para la búsqueda de patrones en cadenas de caracteres u operaciones de sustitución.

Se trata de una herramienta ampliamente utilizada en las ciencias de la computación y necesaria para multitud de aplicaciones que traten con información textual.

Pero... ¿qué pinta tiene una expresión regular? Veamos un primer ejemplo de expresión regular:

>>> regex = '^\d{8}[A-Z]$'

La expresión regular anterior nos permite comprobar que una cadena de texto dada es un DNI válido. Si analizamos parte por parte tendríamos lo siguiente:

• ^ comienzo de línea.
• \d{8} 8 dígitos.
• [A-Z] letra en mayúsculas.
• $ final de línea.

Sintaxis¶

Las expresiones regulares pueden contener tanto caracteres especiales como caracteres ordinarios. La mayoría de los caracteres ordinarios, como 'A', 'b' o '0' son las expresiones regulares más sencillas; simplemente se ajustan a sí mismas.

Existen una serie de caracteres que tienen un significado especial dentro de una expresión regular:

Operaciones¶

Una vez encontrada la expresión regular correspondiente, Python nos ofrece distintos mecanismos que aplicar.

Buscar¶

La búsqueda de patrones es una de las principales utilidades de las expresiones regulares.

Búsqueda simple¶

Supongamos un ejemplo en el que queremos buscar un número de teléfono dentro de un texto. Para ello vamos a utilizar la función search():

>>> import re#(1)!

>>> text = 'Estaré disponible en el +34755142009 el lunes por la tarde'#(2)!

>>> regex = r'\+?\d{2}\d{9}'#(3)!

>>> m = re.search(regex, text)

>>> m#(4)!
<re.Match object; span=(24, 36), match='+34755142009'>

1. Para poder trabajar con expresiones regular debemos importar el paquete re de la librería estándar.
2. Texto de entrada.
3. Definición de la expresión regular:
   • \+? Puede aparecer el signo + como prefijo del teléfono (lo escapamos ya que el punto . es un caracter especial en sí mismo).
   • \d{2} Dos repeticiones de un dígito (prefijo).
   • \d{9} Nueve repeticiones de un dígito (número telefónico en sí mismo).
4. La función search() nos devuelve un objeto tipo Match donde span indica la «ventana» de coincidencia: text[24:36] '+34755142009'

Podemos acceder a la coincidencia encontrada de varias formas:

>>> m[0]#(1)!
'+34755142009'

>>> m.span(0)#(2)!
(24, 36)

1. • El acceso por índice nos devuelve las coindicencias encontradas.
   • Equivalente a usar m.group(0).
2. • El método span() nos devuelve una tupla con los índices de comienzo y finalización de la coincidencia.
   • Equivalente a usar m.start() y m.end().

Podemos aplicar grupos de captura para separar el prefijo y el teléfono siguiendo con el ejemplo anterior:

>>> import re

>>> text = 'Estaré disponible en el +34755142009 el lunes por la tarde'#(2)!

>>> regex = r'\+?(\d{2})(\d{9})'

>>> m = re.search(regex, text)

>>> m[0]
'+34755142009'

>>> m[1]
'34'

>>> m[2]
'755142009'

>>> import re

>>> text = 'Estaré disponible en el +34755142009 el lunes por la tarde'#(2)!

>>> regex = r'\+?(?P<prefix>\d{2})(?P<number>\d{9})'

>>> m = re.search(regex, text)

>>> m[0]
'+34755142009'

>>> m['prefix']
'34'

>>> m['number']
'755142009'

import re

re.search(regex, text, re.IGNORECASE)#(1)!

Búsqueda múltiple¶

En el ejemplo anterior hemos estado buscando una única coincidencia. Imaginemos ahora que queremos encontrar todos los teléfonos. Para ello vamos a utilizar la función findall():

>>> import re

>>> text = """
... Datos de contacto:
...   - Marketing: Rubén López (+49677543181)
...   - Ventas: Sara Mondragón (+34681788902)
...   - Desarrollo: Eva Blasco (+51682131262)
... © Saturno Desarrollos de Software
... """

>>> regex = r'\+?\d{2}\d{9}'

>>> re.findall(regex, text)#(1)!
['+49677543181', '+34681788902', '+51682131262']

1. La función findall() devuelve una lista con las coincidencias encontradas.

Es posible utilizar grupos de captura con la función findall(). Imaginemos que sólo nos interesan los prefijos telefónicos del ejemplo anterior:

>>> import re

>>> text = """
... Datos de contacto:
...   - Marketing: Rubén López (+49677543181)
...   - Ventas: Sara Mondragón (+34681788902)
...   - Desarrollo: Eva Blasco (+51682131262)
... © Saturno Desarrollos de Software
... """

>>> regex = r'\+?(\d{2})\d{9}'#(1)!

>>> re.findall(regex, text)
['49', '34', '51']

1. Mediante los paréntesis () definimos el grupo de captura sobre el prefijo.

Separar¶

Otras de las operaciones ampliamente usadas con expresiones regulares es la separación o división de una cadena de texto mediante un separador.

En su momento vimos el uso de la función split() para cadenas de texto, pero era muy limitada para patrones avanzados. Veamos el uso de la función re.split() dentro de este módulo de expresiones regulares.

Un ejemplo muy sencillo sería separar la parte entera de la parte decimal en un determinado número flotante:

>>> regex = r'[.,]'

>>> re.split(regex, '3.14')
['3', '14']

>>> re.split(regex, '3,14')
['3', '14']

Python también nos da la posibilidad de «capturar» el separador. Siguiendo el ejemplo anterior:

>>> regex = r'([.,])'#(1)!

>>> re.split(regex, '3.14')
['3', '.', '14']

>>> re.split(regex, '3,14')
['3', ',', '14']

1. Usamos paréntesis para añadir un grupo de captura.

Reemplazar¶

El paquete de expresiones regulares re también nos ofrece la posibilidad de reemplazar ocurrencias dentro de un texto. Para ello disponemos de la función sub (regla mnemotécnica viene del inglés «substitute»).

Veamos a continuación un ejemplo de uso en el que recibimos el nombre de una persona en formato <nombre> <apellidos> y queremos convertirlo a formato <apellidos>, <nombre>.

Veamos dos soluciones a este problema utilizando la función re.sub() mediante:

>>> import re

>>> name = 'Alan Turing'

>>> regex = r'(\w+) +(\w+)'#(1)!
>>> repl = r'\2, \1'#(2)!

>>> re.sub(regex, repl, name)#(3)!
'Turing, Alan'

>>> import re

>>> name = 'Alan Turing'

>>> regex = r'(?P<name>\w+) +(?P<surname>\w+)'#(1)!
>>> repl = r'\g<surname>, \g<name>'#(2)!

>>> re.sub(regex, repl, name)#(3)!
'Turing, Alan'    

La función re.sub() admite un uso más avanzado ya que podemos pasar una función en vez de una cadena de texto de reemplazo, lo que nos abre un abanico de posibilidades.

Siguiendo con el ejemplo anterior, supongamos ahora que queremos hacer la misma transformación pero convirtiendo el apellido a mayúsculas, y asegurarnos de que el nombre queda como título:

>>> import re

>>> name = 'Alan Turing'

>>> regex = r'(\w+) +(\w+)'

>>> re.sub(regex, lambda m: f'{m[2].upper()}, {m[1].title()}', name)#(1)!
'TURING, Alan'

1. La función «lambda» recibe el objeto «matcheado» y realiza su modificación mediante los grupos de captura.

Casar¶

Si lo que estamos buscando es comprobar si una determinada cadena de texto «casa» (coincide) con un patrón de expresión regular, podemos hacer uso de la función re.fullmatch().

A continuación se presenta un primer ejemplo que comprueba si un texto dado es un DNI válido:

>>> import re

>>> regex = r'\d{8}[A-Z]'#(1)!

>>> text = '54632178Y'
>>> re.fullmatch(regex, text)#(2)!
<re.Match object; span=(0, 9), match='54632178Y'>

>>> text = '87896532$'#(3)!
>>> re.fullmatch(regex, text)

1. Esta expresión regular es una «simplificación» ya que la letra del DNI (dígito de control) habría que calcularla utilizando un algoritmo definido.
2. Cuando la cadena de texto «casa» con la expresión regular se devuelve un objeto de tipo Match.
3. Cuando la cadena de texto no «casa» con la expresión regular se devuelve None.

En este tipo de escenarios es habitual utilizar el operador morsa para discernir los casos a la vez que creamos una variable:

>>> import re

>>> def check_id_card(text: str) -> None:
...     REGEX = r'(\d{8})([A-Z])'
...     if m := re.fullmatch(REGEX, text):#(1)!
...         print(f'{text} es un DNI válido')
...         print(f'N: {m[1]}  CC: {m[2]}')#(2)!
...     else:
...         print(f'{text} no es un DNI válido')

>>> check_id_card('54632178Y')
54632178Y es un DNI válido
N: 54632178  CC: Y

>>> check_id_card('87896532$')
87896532$ no es un DNI válido

1. En la variable m tendremos el objeto Match en el caso de que la cadena de texto haya casado.
2. Acceso a los grupos de captura.

>>> regex = r'\d{8}[A-Z]'
>>> text = '54632178Y###'

>>> re.match(regex, text)
<re.Match object; span=(0, 9), match='54632178Y'>

>>> regex = r'\d{8}[A-Z]'
>>> text = '###54632178Y'

>>> re.match(regex, text)

En cualquier caso podemos hacer que re.match() se comporte como re.fullmatch() si especificamos los indicadores de comienzo y final de línea en el patrón:

>>> regex = r'^\d{8}[A-Z]$'#(1)!
>>> text = '54632178Y'

>>> re.match(regex, text)
<re.Match object; span=(0, 9), match='54632178Y'>

1. • ^ indica comienzo de línea.
   • $ indica final de línea.

Manejando expresiones largas¶

Hay ocasiones en las que debemos afrontar la elaboración de una expresión regular extensa que incluye varios componentes y puede resultar complicada de leer, o incluso de escribir.

Veamos por ejemplo una expresión regular para comprobar la fortaleza de una contraseña:

>>> import re

>>> regex = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};:"\\|,.<>\/?]).{8,20}$'

>>> re.match(regex, '1234')
>>> re.match(regex, 'python-m0lA')
<re.Match object; span=(0, 11), match='python-m0lA'>

Obviamente resulta difícil de entender al estar escrito todo en una misma línea. Podemos mejorar esta situación desde tres enfoques:

>>> regex = r"""
...     ^                                            # inicio de cadena
...     (?=.*[a-z])                                  # al menos una letra minúscula
...     (?=.*[A-Z])                                  # al menos una letra mayúscula
...     (?=.*\d)                                     # al menos un dígito
...     (?=.*[!@#$%^&*()_+\-=\[\]{};:"\\|,.<>\/?])   # al menos un símbolo
...     .{8,20}                                      # longitud de 8 a 20 caracteres
...     $                                            # final de cadena
... """

>>> re.match(regex, '1234')

>>> re.match(regex, 'python-m0lA', re.VERBOSE)#(1)!
<re.Match object; span=(0, 11), match='python-m0lA'>

>>> lowercase = r'(?=.*[a-z])'
>>> uppercase = r'(?=.*[A-Z])'
>>> digit = r'(?=.*\d)'
>>> symbol = r'(?=.*[!@#$%^&*()_+\-=\[\]{};:"\\|,.<>\/?])'
>>> length = r'.{8,20}'

>>> regex = rf'^{lowercase}{uppercase}{digit}{symbol}{length}$'

>>> re.match(regex, '1234')

>>> re.match(regex, 'python-m0lA')
<re.Match object; span=(0, 11), match='python-m0lA'>

>>> lowercase = r'(?=.*[a-z])'
>>> uppercase = r'(?=.*[A-Z])'
>>> digit = r'(?=.*\d)'
>>> symbol = r'(?=.*[!@#$%^&*()_+\-=\[\]{};:"\\|,.<>\/?])'
>>> length = r'.{8,20}'

>>> regex = rf"""
...     ^             # inicio de cadena
...     {lowercase}   # al menos una letra minúscula
...     {uppercase}   # al menos una letra mayúscula
...     {digit}       # al menos un dígito
...     {symbol}      # al menos un símbolo
...     {length}      # longitud de 8 a 20 caracteres
...     $             # final de cadena
... """

>>> re.match(regex, '1234')

>>> re.match(regex, 'python-m0lA', re.VERBOSE)#(1)!
<re.Match object; span=(0, 11), match='python-m0lA'>

Aclaraciones sobre corchetes¶

Hay que tener en cuenta ciertos matices al utilizar corchetes [] en una expresión regular:

1. Los símbolos incluidos en los corchetes pierden su significado especial:

   >>> re.match(r'[.]', 'A')#(1)!
   
   >>> re.match(r'[.]', '.')#(2)!
   <re.Match object; span=(0, 1), match='.'>
   

   1. No casa...
   2. Sí casa...

2. El guión medio hay que escaparlo en situaciones donde no represente un rango:

   >>> re.match(r'[-\d\s]', '-')#(1)!
   <re.Match object; span=(0, 1), match='-'>
   
   >>> re.match(r'[\d\s-]', '-')#(2)!
   <re.Match object; span=(0, 1), match='-'>
   
   >>> re.match(r'[\d\-\s]', '-')#(3)!
   <re.Match object; span=(0, 1), match='-'>
   

   1. No hay que escapar ya que no representa un rango.
   2. No hay que escapar ya que no representa un rango.
   3. Hay que escapar porque «parece» que representa un rango.

Ejercicios¶

1. pypas   vowel-words
2. pypas   valid-float
3. pypas   valid-email
4. pypas   calc-from-str
5. pypas   valid-url