Python integra el soporte para expresiones regulares a través de su módulo incorpoardo re. Las expresiones regulares son una herramienta formidable para la búsqueda y manipulaicón de texto, permitiendo definir patrones de búsqueda complejos mediante cadenas de texto concisas.

Operaciones Fundamentales con Expresiones Regulares en Python

1. Inclusión del Módulo

Para comenzar a utilizar funcionalidades de expresiones regulares, es necesario importar el módulo re.

import re

2. Métodos de Procesamiento de Patrones

2.1 Búsqueda de Coincidencias

• re.search(pattern, string): Escanea la string en busca de la primera ubicación donde el pattern de expresión regular produce una coincidencia. Devuelve un objeto de coincidencia si se encuentra, o None si no se encuentra ninguna coincidencia.

# Busca la primera secuencia de dígitos en cualquier parte de la cadena
resultado_busqueda = re.search(r'\d+', 'Texto con 123 numeros y 456 mas')
if resultado_busqueda:
    print(f"Primer grupo de números encontrado: {resultado_busqueda.group()}")
# Salida esperada: Primer grupo de números encontrado: 123

• re.match(pattern, string): Intenta hacer coincidir el pattern solo al principio de la string. Si la cadena comienza con el patrón, devuelve un objeto de coincidencia. De lo contrario, devuelve None.

# Intenta hacer coincidir el patrón solo al inicio de la cadena
coincidencia_inicio = re.match(r'^\d+', '789 prefijo')
if coincidencia_inicio:
    print(f"Coincidencia al inicio: {coincidencia_inicio.group()}")
# Salida esperada: Coincidencia al inicio: 789

coincidencia_fallida = re.match(r'^\d+', 'prefijo 789')
if not coincidencia_fallida:
    print("No hubo coincidencia al inicio.")
# Salida esperada: No hubo coincidencia al inicio.

2.2 Captura de Grupos

Los paréntesis () dentro de una expresión regular definen grupos de captura. Estos permiten extraer subcadenas específicas de la coincidencia total.

patron_fechas = r'(\d{4})-(\d{2})-(\d{2})' # Grupo 1: Año, Grupo 2: Mes, Grupo 3: Día
match_fecha = re.search(patron_fechas, 'La fecha es 2024-03-15')
if match_fecha:
    print(f"Año: {match_fecha.group(1)}")    # Salida: Año: 2024
    print(f"Mes: {match_fecha.group(2)}")    # Salida: Mes: 03
    print(f"Día: {match_fecha.group(3)}")    # Salida: Día: 15
    print(f"Coincidencia completa: {match_fecha.group(0)}") # Salida: Coincidencia completa: 2024-03-15

2.3 Sustitución de Texto

• re.sub(pattern, repl, string): Reemplaza todas las ocurrencias del pattern en la string con la cadena repl.

texto_original = "El gato negro persigue al gato blanco."
texto_modificado = re.sub(r'gato', 'perro', texto_original)
print(texto_modificado)
# Salida esperada: El perro negro persigue al perro blanco.

# Sustitución con referencia a grupos capturados
texto_numeros = "ID: 12345, Código: 67890"
texto_permutado = re.sub(r'(\d+), (\d+)', r'\2, \1', texto_numeros)
print(texto_permutado)
# Salida esperada: ID: 67890, Código: 12345

2.4 División de Cadenas

• re.split(pattern, string): Divide la string utilizando el pattern como delimitador.

elementos = re.split(r'[;,.\s]\s*', 'manzana,banana;naranja pera')
print(elementos)
# Salida esperada: ['manzana', 'banana', 'naranja', 'pera']

3. Compilación de Patrones

Para mejorar el rendimiento cuando se utiliza el mismo patrón de expresión regular múltiples veces, se puede compilar previamente.

• re.compile(pattern): Compila una expresión regular en un objeto de patrón.

patron_compilado = re.compile(r'[a-z]+')
coincidencia = patron_compilado.search('busca_aqui_primero')
if coincidencia:
    print(f"Palabra encontrada: {coincidencia.group()}")
# Salida esperada: Palabra encontrada: busca

Metacaracteres Comunes en Expresiones Regulares

• .: Coincide con cualquier carácter excepto una nueva línea.
• ^: Coincide con el inicio de la cadena.
• $: Coincide con el final de la cadena.
• *: Coincide con el elemento anterior cero o más veces.
• +: Coincide con el elemento anterior una o más veces.
• ?: Coincide con el elemento anterior cero o una vez.
• {m,n}: Coincide con el elemento anterior al menos m veces, pero no más de n veces.
• []: Define un conjunto de caracteres. Ej: [aeiou] coincide con cualquier vocal.
• |: Actúa como un operador OR lógico. Ej: gato|perro coincide con "gato" o "perro".
• \: Carácter de escape. Se usa para eliminar el significado especial de un carácter (ej. \. para coincidir un punto literal) o para indicar secuencias especiales (ej. \d para un dígito).

Funciones Adicionales del Módulo re

• re.findall(pattern, string): Devuelve una lista de todas las subcadenas que coinciden con el patrón.
• re.finditer(pattern, string): Devuelve un iterador que produce objetos de coincidencia para cada coincidencia encontrada.

Las expresiones regulares ofrecen una gran flexibilidad para el procesamiento de texto, pero su complejidad puede aumentar rápidamente. Es recomendable diseñar patrones claros y legibles, aprovechando al máximo las capacidades del módulo re de Python.