Fundamentos de las expresiones regulares

Las expresiones regulares son patrones que permiten identificar y extraer secuencias específicas de texto. En Python, el módulo re ofrece funciones clave para trabajar con estos patrones de manera eficiente.

Caracteres meta esenciales

Los caracteres meta definen reglas de coincidencia. Por ejemplo, ^ indica el inicio de la cadena, $ el final, y . cualquier carácter excepto salto de línea (a menos que se use la bandera re.DOTALL). Los corchetes [abc] coinciden con caracteres individuales, mientras que [^abc] excluye esos caracteres.

Los cuantificadores como * (cero o más repeticiones), + (una o más), y ? (cero o una) controlan la repetición. Las llaves {n}, {n,}, y {n,m} especifican repeticiones exactas o rangos.

Secuencias de escape como \d para dígitos, \w para caracteres alfanuméricos, y \s para espacios en blanco simplifican patrones comunes.

Funciones principales del módulo re

re.findall()

Esta función devuelve una lista con todas las coincidencias del patrón en la cadena. Ejemplo con un patrón de 8 dígitos:

import re

cadena_texto = 'Referencia: 12345678, Otro: 87654321'
expresion_regular = r'\d{8}'  # Buscar secuencias de ocho dígitos
resultados = re.findall(expresion_regular, cadena_texto)
print(resultados)  # Salida: ['12345678', '87654321']

re.search()

Busca la primera coincidencia del patrón y devuelve un objeto de coincidencia si existe. Ejemplo:

import re

texto_datos = 'ID: 456, Código: 78901'
patron_busqueda = r'\d{3,5}'
coincidencia = re.search(patron_busqueda, texto_datos)
if coincidencia:
    print(coincidencia.group())  # Salida: '456'

re.match()

Comprueba si el patrón coincide al inicio de la cadena. Ejemplo con un patrón complejo:

import re

entrada = 'Usuario: María Edad: 32 Teléfono: 911223344'
regla = 'Usuario: \\w+ Edad: \\d+ Teléfono: \\d{9}'
resultado_match = re.match(regla, entrada)
if resultado_match:
    print(resultado_match.group())  # Salida completa coincidente

Uso de grupos para extracción

Los grupos con paréntesis permiten capturar partes específicas del patrón. Ejemplo:

import re

datos = 'Nombre: Carlos, Edad: 45, Email: carlos@ejemplo.com'
patron_grupos = 'Nombre: (\\w+), Edad: (\\d+), Email: (\\S+)'
resultado_grupo = re.match(patron_grupos, datos)
if resultado_grupo:
    print(resultado_grupo.group(1))  # Carlos
    print(resultado_grupo.group(2))  # 45

Se pueden asignar nombres a los grupos usando la sintaxis (?P<nombre>expresión) para mayor clariadd.

Compilación de patrones con re.compile()

Para reutilizar patrones frecuantes, se pueden compilar previamente. Ejemplo:

import re

patron_compilado = re.compile(r'Nombre: (?P<nombre>\\w+)')
cadena = 'Nombre: Luis'
res = patron_compilado.match(cadena)
if res:
    print(res.group('nombre'))  # Luis

Sustitución con re.sub()

re.sub() reemplaza coincidencias en una cadena, ofreciendo más flexibilidad que métodos simples de reemplazo. Ejemplo:

import re

texto_original = 'Valor: 12345, Otro: 67890'
patron_sustituir = r'\d{5}'
texto_modificado = re.sub(patron_sustituir, 'XXXXX', texto_original)
print(texto_modificado)  # Salida: 'Valor: XXXXX, Otro: XXXXX'

Modos de coincidencia multilínea

Las banderas como re.M permiten tratar cada línea por separado, mientras que re.S hace que el punto coincida con todos los caracteres, incluyendo saltos de línea.

Coincidencias codiciosas y no codiciosas

Por defecto, los cuantificadores son codiciosos, buscando la coincidencia más larga posible. Al añadir ?, se vuelven no codiciosos, buscando la más corta. Ejemplo con múltiples nombres:

import re

cadena_ejemplo = '''Nombre: Ana Edad: 29 Teléfono: 999888777 Nombre: Pedro Edad: 41 Teléfono: 111222333'''
patron_codicioso = 'Nombre: (.*) Edad'
print('Codicioso:', re.findall(patron_codicioso, cadena_ejemplo))
patron_no_codicioso = 'Nombre: (.*?) Edad'
print('No codicioso:', re.findall(patron_no_codicioso, cadena_ejemplo))

La salida muestra cómo el modo codicioso captura texto adicional, mientras el no codicioso se limita a la primera ocurrencia.