En este capítulo, explorarás cómo aprovechar el poder de las expresiones regulares en escenarios avanzados de Python, incluyendo el trabajo con funciones anidadas, inversión de cadenas y unión de cadenas. Estas técnicas permiten manipular y analizar datos de texto de manera más eficiente y flexible, desbloqueando nuevas posibilidades para la automatización, limpieza de datos y coincidencia de patrones complejos.

Aprenderás cómo las expresiones regulares pueden:

• Mejorar la funcionalidad de las funciones anidadas para extraer o transformar datos;
• Simplificar el proceso de invertir cadenas según patrones específicos;
• Permitir la unión dinámica y personalizable de cadenas utilizando reglas basadas en patrones.

Dominar estas aplicaciones te ayudará a escribir código Python más conciso, legible y potente para una amplia gama de tareas del mundo real, desde el procesamiento de archivos de registro hasta la construcción de canalizaciones de datos.

Uso de expresiones regulares dentro de funciones anidadas

Cuando utilizas expresiones regulares en Python, a menudo defines patrones y lógica de búsqueda dentro de funciones. En ocasiones, puedes necesitar usar expresiones regulares dentro de funciones anidadas — funciones definidas dentro de otras funciones. Comprender cómo funcionan el alcance y el acceso a variables en este contexto te ayuda a escribir código claro y reutilizable.

Definición: Funciones anidadas

Una función anidada es una función definida dentro de otra función. La función interna puede acceder a variables de la función que la contiene gracias al alcance léxico de Python (también llamado cierre).

Alcance y expresiones regulares

• La función interna puede usar patrones de expresiones regulares y objetos compilados definidos en la función externa;
• Puedes pasar coincidencias o resultados de expresiones regulares de la función externa a la interna para su posterior procesamiento;
• Compilar un patrón regex en la función externa mejora la eficiencia si la función interna utiliza el mismo patrón varias veces.

Ejemplo práctico: Filtrado y extracción de datos

Supón que deseas procesar una lista de direcciones de correo electrónico, filtrando las válidas y extrayendo la parte del nombre de usuario. Puedes usar una función anidada para encapsular la lógica de extracción:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Puntos clave:

• El pattern se compila una vez en la función externa y se reutiliza en la función anidada extract_username;
• La función interna accede al patrón regex desde el alcance envolvente;
• Esta estructura mantiene el código organizado y eficiente, especialmente al manejar tareas complejas de análisis de datos.

El uso de expresiones regulares dentro de funciones anidadas es una técnica poderosa para construir código modular y mantenible que procesa datos de texto de manera eficiente.

Inversión de cadenas en Python

Invertir una cadena es una tarea común que puedes encontrar al procesar datos de texto. Python ofrece una forma sencilla de invertir cadenas utilizando el corte (slicing), y también puedes combinar esto con expresiones regulares para una manipulación avanzada de texto.

Cómo invertir una cadena

Puedes invertir cualquier cadena en Python usando slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Explicación:

• text[::-1] crea una nueva cadena tomando todos los caracteres de text pero en orden inverso.

Escenarios de uso

Invertir cadenas es útil en varias situaciones:

• Verificación de si una cadena es un palíndromo;
• Ocultamiento de información sensible mostrándola al revés;
• Creación de efectos de texto divertidos para interfaces de usuario.

Combinando expresiones regulares con inversión de cadenas

Puedes usar expresiones regulares para encontrar patrones específicos en una cadena y luego invertir solo esas partes. Esto es útil cuando deseas invertir ciertas palabras o patrones, no toda la cadena.

Ejemplo: invertir todas las palabras que comienzan con mayúscula

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Cómo funciona:

• El patrón de regex \b[A-Z][a-zA-Z]*\b coincide con palabras que comienzan con una letra mayúscula.
• La función reverse_match invierte cada palabra coincidente.
• re.sub reemplaza cada coincidencia por su versión invertida.

Combinar expresiones regulares con la inversión de cadenas permite realizar transformaciones de texto complejas de manera concisa y flexible.

Unir cadenas en Python

Unir cadenas es una tarea común al trabajar con datos de texto. A menudo es necesario combinar varias cadenas en una sola, como unir palabras, líneas o resultados de una búsqueda con expresiones regulares.

Uso de join() para combinar una lista de cadenas

El método str.join() es la forma estándar de concatenar una lista de cadenas en una sola cadena. Se especifica una cadena separadora y se llama a join() con la lista que se desea combinar.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Puntos clave sobre join():

• El separador (como un espacio, coma o salto de línea) se coloca antes de .join();
• El argumento de join() debe ser un iterable de cadenas (como una lista o tupla);
• El resultado es una sola cadena que contiene todos los elementos, separados por el separador elegido.

Unir coincidencias de regex en una sola cadena

Cuando se utiliza la función re.findall(), esta devuelve una lista de todas las coincidencias no superpuestas. Puedes usar join() para combinar estas coincidencias en una sola cadena.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Casos de uso comunes:

• Combinar todas las coincidencias de regex en una cadena separada por comas;
• Unir líneas de texto en un solo bloque;
• Crear líneas CSV a partir de listas de valores.

Unir cadenas de manera eficiente ayuda a procesar, mostrar y almacenar datos de texto de forma legible y estructurada.