Expresiones Regulares (Regex)

import re

texto = "Mi teléfono es 555-1234"
patron = r"\d{3}-\d{4}"

resultado = re.search(patron, texto)
if resultado:
    print(f"Encontrado: {resultado.group()}")
else:
    print("No encontrado")

import re

texto = "Python es un lenguaje de programación"
patron = r"Python"

if re.search(patron, texto):
    print("Se encontró 'Python'")

re.findall(r"c.sa", "casa cosa cesa")

re.search(r"^Hola", "Hola mundo")

re.search(r"mundo$", "Hola mundo")

re.findall(r"lo*", "l lo loo looo")

re.findall(r"lo+", "l lo loo looo")

re.findall(r"lo?", "l lo loo")

re.findall(r"\d{3}", "El código es 12, 123, 1234 y 12345")

re.findall(r"\d{3,}", "El código es 12, 123, 1234 y 12345")

re.findall(r"\d{,3}", "El código es 12, 123, 1234 y 12345")

re.findall(r"\d{2,4}", "El código es 12, 123, 1234 y 12345")

re.findall(r"[A-Z]", "El código postal es A1234BCZ")

re.findall(r"[0-9]+", "El código postal es A1234BCZ")

re.findall(r"[A-Z0-9]+", "El código postal es A1234BCZ")

re.findall(r"[^ ]+", "El código postal es A1234BCZ")

re.findall(r"\d+", "Usuario: juan_123, Email: juan@email.com")

re.findall(r"\w+", "Usuario: juan_123, Email: juan@email.com")

re.findall(r"\bjuan\b", "Usuario: juan_123, Email: juan@email.com")

re.findall(r"\bjuan", "juanito juan")

import re

texto = "Los emails son: juan@email.com, ana@empresa.com.ar y pedro@sitio.org"

# search: encuentra la primera coincidencia
if resultado := re.search(r"\w+@\w+\.\w+", texto):
    print(f"Primer email encontrado: {resultado.group()}")

# findall: encuentra todas las coincidencias
emails = re.findall(r"\w+@[\w.]+", texto)
print(f"Todos los emails: {emails}")

# finditer: iterador sobre las coincidencias
for match in re.finditer(r"\w+@[\w.]+", texto):
    print(f"Email en posición {match.start()}-{match.end()}: {match.group()}")

import re

# Compilar el patrón una sola vez
patron_email = re.compile(r"\w+@[\w.]+")

textos = [
    "Contacto: juan@email.com",
    "Soporte: ayuda@empresa.com",
    "Ventas: ventas@sitio.org",
]

for texto in textos:
    if match := patron_email.search(texto):
        print(f"{texto} -> {match.group()}")

import re

texto = "Fecha: 15/03/2024"
patron = r"(\d{2})/(\d{2})/(\d{4})"

if match := re.search(patron, texto):
    print(f"Fecha completa: {match.group(0)}")  # Toda la coincidencia
    print(f"Día: {match.group(1)}")  # Primer grupo
    print(f"Mes: {match.group(2)}")  # Segundo grupo
    print(f"Año: {match.group(3)}")  # Tercer grupo
    print(f"Todos los grupos: {match.groups()}")  # Tupla con todos los grupos

import re

texto = "Producto: ABC-123 Precio: $450.50"
patron = r"(?P<codigo>[A-Z]+-\d+).*?\$(?P<precio>\d+\.\d+)"

if match := re.search(patron, texto):
    print(f"Código: {match.group('codigo')}")
    print(f"Precio: {match.group('precio')}")
    print(f"Diccionario: {match.groupdict()}")

# foo seguido de un dígito
re.findall(r"foo(?=\d)", "foo1 bar2 foo3 baz4 foo baz")

# dígito precedido de foo
re.findall(r"(?<=foo)\d", "foo1 bar2 foo3 baz4 5 6")

import re


def validar_email(email):
    """Valida un email con expresión regular"""
    patron = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    return re.match(patron, email) is not None


def validar_telefono_argentina(telefono):
    """Valida teléfono argentino: +54 11 1234-5678"""
    patron = r"^\+54\s?\d{2}\s?\d{4}-?\d{4}$"
    return re.match(patron, telefono) is not None


def validar_url(url):
    """Valida una URL"""
    patron = r"^https?://(www\.)?[\w.-]+\.[a-z]{2,}(/[\w.-]*)*/?$"
    return re.match(patron, url) is not None


# Pruebas
print(f"Email válido: {validar_email('juan@email.com')}")
print(f"Email inválido: {validar_email('juan@email')}")
print(f"Teléfono válido: {validar_telefono_argentina('+54 11 1234-5678')}")
print(f"URL válida: {validar_url('https://www.ejemplo.com/path')}")

import re

# Texto de ejemplo: log de servidor web
log = """
192.168.1.1- -[15/Mar/2024:10:30:45 +0000] "GET /index.html HTTP/1.1" 200 1234
10.0.0.5- -[15/Mar/2024:10:31:12 +0000] "POST /api/data HTTP/1.1" 201 567
192.168.1.1- -[15/Mar/2024:10:32:33 +0000] "GET /styles.css HTTP/1.1" 200 8910
"""

# Patrón para extraer información del log
patron = (
    r"(\d+\.\d+\.\d+\.\d+).*?\[([^\]]+)\]"  # IP y fecha
    r'\s+"(\w+)\s+([^\s]+).*?"\s+(\d+)\s+(\d+)'  # Método, ruta, código y tamaño
)

for linea in log.strip().split("\n"):
    if match := re.search(patron, linea):
        ip, fecha, metodo, ruta, codigo, tamaño = match.groups()
        print(f"IP: {ip}")
        print(f"Fecha: {fecha}")
        print(f"Método: {metodo}")
        print(f"Ruta: {ruta}")
        print(f"Código: {codigo}")
        print(f"Tamaño: {tamaño} bytes")
        print("---")

import re


def limpiar_texto(texto):
    """Limpia un texto para procesamiento"""
    # Eliminar URLs
    texto = re.sub(r"https?://\S+", "", texto)

    # Eliminar emails
    texto = re.sub(r"\S+@\S+", "", texto)

    # Eliminar múltiples espacios
    texto = re.sub(r"\s+", " ", texto)

    # Eliminar caracteres especiales (mantener letras, números y espacios)
    texto = re.sub(r"[^\w\s]", "", texto)

    return texto.strip()


texto_sucio = """
Visita https://ejemplo.com para más info!
Contacto: info@ejemplo.com
   Múltiples    espacios   aquí...
¿Caracteres especiales? @#$%
"""

print("Texto original:")
print(texto_sucio)
print()
print("Texto limpio:")
print(limpiar_texto(texto_sucio))

def tokenizar(texto):
    """Divide un texto en palabras (tokens)"""
    # Encontrar todas las secuencias de caracteres de palabra
    return re.findall(r"\b\w+\b", texto.lower())

def normalizar_token(token):
    # Eliminar puntuación al inicio/final del token
    token = re.sub(r"^[^\w]+|[^\w]+$", "", token)
    return token.lower()

# Contar frecuencia de palabras
from collections import Counter

texto = "Python es un lenguaje de programación. ¡Es genial!"
tokens = tokenizar(texto)
print(f"Tokens: {tokens}")
print(f"Total de tokens: {len(tokens)}")

frecuencias = Counter(tokens)
print(f"Palabras más comunes: {frecuencias.most_common(3)}")

import re

# Crear un archivo de ejemplo
contenido_archivo = """
Estructuras de datos
Python es un lenguaje de programación versátil
Expresiones regulares son herramientas poderosas
Python se usa en ciencia de datos
Las estructuras de datos son fundamentales
"""

with open("ejemplo.txt", "w") as f:
    f.write(contenido_archivo)


def buscar_en_archivo(archivo, patron):
    """Busca un patrón en un archivo y devuelve las líneas que coinciden"""
    resultados = []
    with open(archivo, "r") as f:
        for num_linea, linea in enumerate(f, 1):
            if re.search(patron, linea, re.IGNORECASE):
                resultados.append((num_linea, linea.strip()))
    return resultados


# Buscar líneas que contengan "Python" o "datos"
patron = r"Python|datos"
resultados = buscar_en_archivo("ejemplo.txt", patron)

print("Líneas encontradas:")
for num, linea in resultados:
    print(f"{num}: {linea}")

import re

# HTML de ejemplo
html = """
<div class="producto">
    <h2>Laptop HP</h2>
    <p class="precio">$899.99</p>
    <p>Procesador Intel i7</p>
</div>
<div class="producto">
    <h2>Mouse Logitech</h2>
    <p class="precio">$25.50</p>
    <p>Inalámbrico</p>
</div>
"""


def extraer_productos(html):
    """Extrae información de productos del HTML"""
    # Patrón para encontrar bloques de productos
    patron_producto = r'<div class="producto">.*?<h2>(.*?)</h2>.*?<p class="precio">\$([\d.]+)</p>'

    productos = re.findall(patron_producto, html, re.DOTALL)

    return [
        {"nombre": nombre, "precio": float(precio)}
        for nombre, precio in productos
    ]


productos = extraer_productos(html)
for i, prod in enumerate(productos, 1):
    print(f"Producto {i}: {prod['nombre']} - ${prod['precio']}")

import re


def anonimizar_datos(texto):
    """Anonimiza datos sensibles en un texto"""
    # Anonimizar emails
    texto = re.sub(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", "[EMAIL]", texto)

    # Anonimizar teléfonos (formato: xxx-xxxx o (xxx) xxx-xxxx)
    texto = re.sub(r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}", "[TELÉFONO]", texto)

    # Anonimizar números de tarjeta (grupos de 4 dígitos)
    texto = re.sub(r"\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b", "[TARJETA]", texto)

    return texto


texto_sensible = """
Contacto: juan.perez@email.com
Teléfono: 555-1234 o (555) 555-5678
Tarjeta: 1234 5678 9012 3456
"""

print("Texto original:")
print(texto_sensible)
print("\nTexto anonimizado:")
print(anonimizar_datos(texto_sensible))

import re
from collections import Counter


def analizar_texto(texto):
    """Analiza un texto y extrae métricas"""
    # Contar oraciones (terminan en . ! ?)
    oraciones = re.split(r"[.!?]+", texto)
    num_oraciones = len([s for s in oraciones if s.strip()])

    # Contar palabras
    palabras = re.findall(r"\b\w+\b", texto.lower())
    num_palabras = len(palabras)

    # Palabras más comunes
    frecuencias = Counter(palabras)
    palabras_comunes = frecuencias.most_common(5)

    # Contar números
    numeros = re.findall(r"\b\d+\b", texto)

    # Detectar emails
    emails = re.findall(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", texto)

    # Detectar URLs
    urls = re.findall(r"https?://[^\s]+", texto)

    return {
        "oraciones": num_oraciones,
        "palabras": num_palabras,
        "palabras_comunes": palabras_comunes,
        "numeros": numeros,
        "emails": emails,
        "urls": urls,
    }


texto_ejemplo = """
Python es un lenguaje de programación versátil.
Se utiliza en ciencia de datos, desarrollo web y automatización.
El curso tiene 50 estudiantes y 5 profesores!
Más información en https://ejemplo.com
Contacto: info@ejemplo.com
Python es muy popular. Python es fácil de aprender.
"""

metricas = analizar_texto(texto_ejemplo)
print("Análisis del texto:")
print(f"Oraciones: {metricas['oraciones']}")
print(f"Palabras: {metricas['palabras']}")
print(f"Palabras más comunes: {metricas['palabras_comunes']}")
print(f"Números encontrados: {metricas['numeros']}")
print(f"Emails encontrados: {metricas['emails']}")
print(f"URLs encontradas: {metricas['urls']}")

import re

# IGNORECASE
texto = "Python python PYTHON"
print(re.findall(r"python", texto, re.IGNORECASE))

# MULTILINE
texto_multilinea = """Primera línea
Segunda línea
Tercera línea"""
print(re.findall(r"^.*línea", texto_multilinea, re.MULTILINE))

# VERBOSE: patrón más legible
patron_email = re.compile(
    r"""
    ^                      # Inicio de la cadena
    [a-zA-Z0-9._%+-]+      # Usuario
    @                      # @
    [a-zA-Z0-9.-]+         # Dominio
    \.                     # .
    [a-zA-Z]{2,}           # Extensión
    $                      # Fin de la cadena
    """,
    re.VERBOSE,
)

print(patron_email.match("usuario@ejemplo.com"))

import re


def validar_contraseña(password):
    """
    Valida que una contraseña cumpla con:
    - Al menos 8 caracteres
    - Al menos una letra mayúscula
    - Al menos una letra minúscula
    - Al menos un dígito
    - Al menos un carácter especial
    """
    if len(password) < 8:
        return False, "Debe tener al menos 8 caracteres"

    if not re.search(r"[A-Z]", password):
        return False, "Debe tener al menos una mayúscula"

    if not re.search(r"[a-z]", password):
        return False, "Debe tener al menos una minúscula"

    if not re.search(r"\d", password):
        return False, "Debe tener al menos un dígito"

    if not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
        return False, "Debe tener al menos un carácter especial"

    return True, "Contraseña válida"


# Pruebas
contraseñas = ["123456", "abcdefgh", "Abcdefgh", "Abcdefgh1", "Abcdefgh1!"]

for pwd in contraseñas:
    valida, mensaje = validar_contraseña(pwd)
    print(f"{pwd}: {mensaje}")

import re


def extraer_informacion_contacto(texto):
    """Extrae emails, teléfonos y URLs de un texto"""

    # Patrón para emails
    email_pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
    emails = re.findall(email_pattern, texto)

    # Patrón para teléfonos (varios formatos)
    telefonos = re.findall(
        r"\+?\d{1,3}?[-.\s]?\(?\d{1,4}\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}", texto
    )

    # Patrón para URLs
    urls = re.findall(r"https?://[^\s]+", texto)

    return {"emails": emails, "telefonos": telefonos, "urls": urls}


texto_contacto = """
Para más información:
- Email: contacto@empresa.com o soporte@empresa.com.ar
- Teléfono: +54 11 4567-8900 o 555-1234
- Web: https://www.empresa.com y https://soporte.empresa.com/ayuda
"""

info = extraer_informacion_contacto(texto_contacto)
print("Información extraída:")
print(f"Emails: {info['emails']}")
print(f"Teléfonos: {info['telefonos']}")
print(f"URLs: {info['urls']}")

import re


def procesar_tweet(texto):
    """Extrae menciones y hashtags de un texto estilo Twitter"""

    # Menciones: @usuario
    menciones = re.findall(r"@(\w+)", texto)

    # Hashtags: #etiqueta
    hashtags = re.findall(r"#(\w+)", texto)

    # URLs
    urls = re.findall(r"https?://\S+", texto)

    # Texto limpio (sin menciones, hashtags ni URLs)
    texto_limpio = re.sub(r"@\w+|#\w+|https?://\S+", "", texto)
    texto_limpio = re.sub(r"\s+", " ", texto_limpio).strip()

    return {
        "menciones": menciones,
        "hashtags": hashtags,
        "urls": urls,
        "texto_limpio": texto_limpio,
    }


tweet = """
Gran clase de @profesorEDD sobre #ExpresionesRegulares!
#Python es genial para #DataScience
Más info: https://ejemplo.com/curso
cc: @estudiante1 @estudiante2
"""

resultado = procesar_tweet(tweet)
print("Análisis del tweet:")
print(f"Menciones: {resultado['menciones']}")
print(f"Hashtags: {resultado['hashtags']}")
print(f"URLs: {resultado['urls']}")
print(f"Texto limpio: {resultado['texto_limpio']}")

import re
import time

texto = "Python es genial. Python es versátil. Python es popular." * 1000

# Sin compilar
start = time.perf_counter()
for _ in range(1000):
    re.findall(r"Python", texto)
end = time.perf_counter()
tiempo_sin_compilar = end - start

# Con compilación
patron = re.compile(r"Python")
start = time.perf_counter()
for _ in range(1000):
    patron.findall(texto)
end = time.perf_counter()
tiempo_con_compilar = end - start

print(f"Sin compilar: {tiempo_sin_compilar:.4f} segundos")
print(f"Con compilar: {tiempo_con_compilar:.4f} segundos")
print(f"Mejora: {tiempo_sin_compilar / tiempo_con_compilar:.2f}x más rápido")

import re

# Patrón ineficiente con backtracking
# patron_malo = r"(a+)+"  # Puede ser muy lento

# Mejor: usar cuantificadores específicos
patron_bueno = r"a+"

texto = "a" * 20 + "b"
print(re.search(patron_bueno, texto))

import re

# Sin raw string (necesita doble escape)
patron1 = "\\d+\\s+\\w+"

# Con raw string (más legible)
patron2 = r"\d+\s+\w+"

texto = "123 palabras"
print(re.search(patron1, texto).group())
print(re.search(patron2, texto).group())

import re
from collections import defaultdict


class IndiceInvertido:
    """Índice invertido que usa regex para procesar documentos"""

    def __init__(self):
        self.indice = defaultdict(set)

    def agregar_documento(self, doc_id, texto):
        """Agrega un documento al índice"""
        # Tokenizar usando regex
        palabras = re.findall(r"\b\w+\b", texto.lower())

        for palabra in palabras:
            self.indice[palabra].add(doc_id)

    def buscar(self, patron):
        """Busca documentos que contengan palabras que coincidan
        con el patrón"""
        patron_compilado = re.compile(patron, re.IGNORECASE)
        documentos = set()

        for palabra in self.indice.keys():
            if patron_compilado.search(palabra):
                documentos.update(self.indice[palabra])

        return documentos


# Crear índice
indice = IndiceInvertido()
indice.agregar_documento(1, "Python es un lenguaje de programación")
indice.agregar_documento(2, "Programar en Python es divertido")
indice.agregar_documento(3, "Java y JavaScript son diferentes")

# Buscar documentos que contengan palabras que empiecen con "prog"
docs = indice.buscar(r"^prog")
print(f"Documentos con palabras que empiezan con 'prog': {docs}")

# Buscar documentos con palabras que contengan "python"
docs = indice.buscar(r"python")
print(f"Documentos con 'python': {docs}")

import re

# Lista de archivos
archivos = [
    "documento1.txt",
    "imagen.png",
    "datos.csv",
    "reporte_2024.pdf",
    "script.py",
    "backup_2024_03_15.zip",
]


def filtrar_archivos(archivos, patron):
    """Filtra archivos que coincidan con el patrón"""
    patron_compilado = re.compile(patron)
    return [archivo for archivo in archivos if patron_compilado.search(archivo)]


# Filtrar archivos de texto
print("Archivos .txt:", filtrar_archivos(archivos, r"\.txt$"))

# Filtrar archivos de 2024
print("Archivos de 2024:", filtrar_archivos(archivos, r"2024"))

# Filtrar archivos Python
print("Archivos Python:", filtrar_archivos(archivos, r"\.py$"))