Ir al contenido principal

Expresiones regulares con re

Introducción

Las expresiones regulares son patrones de búsqueda que permiten realizar operaciones avanzadas con cadenas de texto. En Python, el módulo re proporciona todas las herramientas necesarias para trabajar con estos patrones, permitiéndonos buscar, extraer, reemplazar y validar texto de forma potente y flexible. Aunque al principio pueden parecer crípticas, las expresiones regulares son una habilidad fundamental para cualquier programador que trabaje con procesamiento de texto.

Conceptos básicos de expresiones regulares

Las expresiones regulares (también llamadas "regex") son secuencias de caracteres que forman un patrón de búsqueda. Veamos cómo importar el módulo re y empezar a utilizarlo:

import re

# Buscamos la palabra "Python" en una cadena
texto = "Estoy aprendiendo Python en 2025"
resultado = re.search("Python", texto)

if resultado:
    print("¡Encontrado!")
    print(f"La palabra comienza en la posición {resultado.start()} y termina en {resultado.end()}")
else:
    print("No encontrado")

Funciones principales del módulo re

El módulo re ofrece varias funciones fundamentales:

1. re.search()

Busca un patrón en una cadena y devuelve el primer resultado:

resultado = re.search(patron, texto)

2. re.match()

Similar a search(), pero solo busca al inicio de la cadena:

# Solo encuentra "Hola" si está al principio
resultado = re.match("Hola", texto)

3. re.findall()

Encuentra todas las ocurrencias de un patrón y devuelve una lista:

# Encuentra todos los números en el texto
numeros = re.findall(r'\d+', "Tengo 3 manzanas y 2 peras")
print(numeros)  # ['3', '2']

4. re.sub()

Sustituye las coincidencias por otro texto:

# Reemplaza los números por "X"
nuevo_texto = re.sub(r'\d', 'X', "Mi teléfono es 123456789")
print(nuevo_texto)  # Mi teléfono es XXXXXXXXX

5. re.split()

Divide una cadena según un patrón:

# Divide usando espacios o comas como separadores
palabras = re.split(r'[, ]+', "manzanas, peras naranjas,plátanos")
print(palabras)  # ['manzanas', 'peras', 'naranjas', 'plátanos']

Metacaracteres y símbolos especiales

Los metacaracteres son caracteres con significado especial en las expresiones regulares:

# Algunos metacaracteres importantes
# . - Cualquier carácter excepto nueva línea
# ^ - Inicio de cadena
# $ - Fin de cadena
# * - 0 o más repeticiones
# + - 1 o más repeticiones
# ? - 0 o 1 repetición
# {} - Número específico de repeticiones
# [] - Conjunto de caracteres
# | - O lógico (alternativa)
# () - Agrupación

# Ejemplos:
emails = re.findall(r'[\w.-]+@[\w.-]+\.\w+', "Contacta con juan@ejemplo.com o maria@correo.es")
print(emails)  # ['juan@ejemplo.com', 'maria@correo.es']

Clases de caracteres comunes

Las clases de caracteres nos permiten definir conjuntos de caracteres:

# \d - Dígito (0-9)
# \D - No dígito
# \w - Carácter de palabra (letras, números, _)
# \W - No carácter de palabra
# \s - Espacio en blanco
# \S - No espacio en blanco

# Ejemplo: encontrar palabras que contengan números
palabras_con_numeros = re.findall(r'\w*\d+\w*', "abc123 def xyz789")
print(palabras_con_numeros)  # ['abc123', 'xyz789']

Grupos de captura

Los paréntesis permiten crear grupos de captura para extraer partes específicas:

texto = "Mi nombre es Ana y tengo 25 años"
resultado = re.search(r'Mi nombre es (\w+) y tengo (\d+) años', texto)

if resultado:
    nombre = resultado.group(1)
    edad = resultado.group(2)
    print(f"Nombre: {nombre}, Edad: {edad}")  # Nombre: Ana, Edad: 25

Uso de flags

Los flags modifican el comportamiento de las expresiones regulares:

# re.IGNORECASE o re.I - Ignora mayúsculas/minúsculas
resultado = re.search("python", "Aprendo PYTHON", re.IGNORECASE)
print(resultado is not None)  # True

# re.MULTILINE o re.M - ^ y $ coinciden con inicio/fin de cada línea
texto_multilinea = "Línea 1\nLínea 2\nLínea 3"
resultado = re.findall(r'^Línea', texto_multilinea, re.MULTILINE)
print(resultado)  # ['Línea', 'Línea', 'Línea']

# re.DOTALL o re.S - El punto coincide también con saltos de línea

Expresiones regulares compiladas

Para patrones que se utilizan varias veces, es más eficiente compilarlos:

# Compilar un patrón
patron = re.compile(r'\b\w{5}\b')  # Palabras de exactamente 5 letras

# Usar el patrón compilado
texto = "Hola a todos los amigos del curso de Python"
palabras_5 = patron.findall(texto)
print(palabras_5)  # ['todos', 'amigos', 'curso']

Validación de formatos comunes

Las expresiones regulares son perfectas para validar formatos:

def validar_email(email):
    patron = r'^[\w.-]+@[a-zA-Z\d.-]+\.[a-zA-Z]{2,}$'
    return re.match(patron, email) is not None

def validar_telefono_espanol(telefono):
    patron = r'^(?:(?:\+|00)34[-\s]?)?[6789]\d{8}$'
    return re.match(patron, telefono) is not None

# Probamos las funciones
print(validar_email("usuario@dominio.com"))  # True
print(validar_email("usuario@.com"))  # False
print(validar_telefono_espanol("612345678"))  # True
print(validar_telefono_espanol("912345678"))  # True
print(validar_telefono_espanol("51234567"))  # False

Lookbehind y Lookahead

Estas son técnicas avanzadas para buscar patrones solo si están precedidos o seguidos por otros:

# Lookahead positivo (?=...)
# Números seguidos de "€"
precios = re.findall(r'\d+(?=\s*€)', "Tenemos productos de 10 € y 20€")
print(precios)  # ['10', '20']

# Lookbehind positivo (?<=...)
# Palabras precedidas por "Sr."
nombres = re.findall(r'(?<=Sr\.\s)\w+', "Sr. García y Sr. Pérez")
print(nombres)  # ['García', 'Pérez']

Consejos de uso

  • Empieza con patrones simples y ve añadiendo complejidad
  • Usa sitios de prueba online como regex101.com para probar tus expresiones
  • Cuando trabajes con patrones complejos, utiliza comentarios con el flag re.VERBOSE
# Expresión regular con comentarios
patron = re.compile(r'''
    ^                 # Inicio de la cadena
    [\w.-]+           # Parte local del email
    @                 # Símbolo @
    [a-zA-Z\d.-]+     # Dominio sin TLD
    \.                # Punto
    [a-zA-Z]{2,}      # TLD (com, es, org, etc.)
    $                 # Fin de la cadena
''', re.VERBOSE)

Resumen

Las expresiones regulares son una herramienta poderosa para manipular y analizar texto. El módulo re de Python proporciona todas las funcionalidades necesarias para trabajar con ellas de manera efectiva. Aunque la sintaxis puede parecer complicada al principio, con práctica se convierten en un recurso indispensable para cualquier tarea que involucre procesamiento de texto.

Dominar las expresiones regulares te permitirá realizar operaciones de búsqueda, extracción y validación de texto que serían extremadamente difíciles o verbosas con métodos tradicionales. En los próximos temas, veremos cómo aplicar este conocimiento junto con otras bibliotecas para tareas de procesamiento de datos más avanzadas.

Volver arriba