Si trabajas con cadenas en tus scripts de Python y estás escribiendo una dialéctica oscura para procesarlas, entonces necesitas despabilarse expresiones regulares en Python. Le permite describir patrones en superficie de escribir dialéctica procesal. Veamos algunos ejemplos del mundo actual en los que Python re El módulo hace que los scripts sean más inteligentes.

Validar entradas furtivas de usuarios

Al validar la entrada del beneficiario sin expresiones regulares, probablemente haya escrito un código que parecía incorrecto. Supongamos que desea validar un nombre de beneficiario con estas reglas:

• Sólo trivio, números y guiones bajos.

• Debe comenzar con una grafema.

• Distancia entre 3 y 16 caracteres

Este es un requisito global. Veamos qué necesitas hacer sin usar Python. re módulo:

def is_valid_username(username):
    if len(username) < 3 or len(username) > 16:
        return False

    if not username(0).isalpha():
        return False

    for char in username:
        if not (char.isalnum() or char == "_"):
            return False

    return True

Esto funciona, pero es detallado, comprensible de meter la pata y cada nueva regla significa unir más dialéctica. Ahí es exactamente donde el re El módulo brilla. Describes las reglas de forma declarativa usando re.compile() y usa ese patrón en todas partes:

import re

USERNAME_PATTERN = re.compile(r"^(a-zA-Z)(a-zA-Z0-9_){2,15}$")

def is_valid_username(username):
    return bool(USERNAME_PATTERN.fullmatch(username))

Entendamos lo que está pasando.

• ^: Esto indica el inicio de la sujeción.
• (a-zA-Z): Debe comenzar con una grafema
• (a-zA-Z0-9_){2,15}: Los caracteres permitidos y la largura restante.
• $: Esto indica el final de la sujeción.

Una vez que comience a validar las entradas con rese vuelve difícil regresar. Usted expresa las reglas directamente y Python hace el trabajo pesado.

Relacionado

Seis razones por las que Python interactivo cambia las reglas del serie para mí

¿Sin software? ¡Ningún problema!

En algún momento, cada script de Python se encuentra con texto lioso. Archivos de registro, capturas de paquetes, correos electrónicos, HTML raspado, entre otros. El desafío es conquistar esa estructura sin escribir código de examen frágil lista por lista.

Imagine que está procesando un archivo de registro de una aplicación y desea extraer marcas de tiempo y mensajes de error. Una lista de registro típica podría hallarse así:

(2025-01-02 14:33:21) ERROR: Connection timed out after 30 seconds

Puedes intentarlo así:

def parse_log_line(line):
    if not line.startswith("("):
        return None

    parts = line.split(")")
    timestamp = parts(0)(1:)

    if "ERROR:" not in parts(1):
        return None

    message = parts(1).split("ERROR:")(1).strip()
    return timestamp, message

Esto funciona para el formato exacto con el que probó. Pero es frágil. Los espacios adicionales, la error de corchetes o una redacción sutilmente diferente pueden romper la dialéctica. Encima, la intención del código está enterrada bajo la entrenamiento con cuerdas. Con el re módulo, puede describir la estructura de la lista en superficie de cortarla manualmente.

import re

LOG_PATTERN = re.compile(
    r"((?P(d-: )+))s+ERROR:s+(?P.+)"
)

def parse_log_line(line):
    match = LOG_PATTERN.search(line)
    if not match:
        return None

    return match.group("timestamp"), match.group("message")

Aquí, le decimos a Python exactamente lo que estamos buscando: una marca de tiempo entre corchetes, seguida de la palabra “ERROR”, seguida del resto del mensaje.

Afanar y ordenar texto en una lista

La pulcritud de texto es una de esas tareas que parece sencilla hasta que positivamente la haces. A menudo tienes que batallar con espacios en blanco adicionales, separadores inconsistentes, puntuación aleatoria o peculiaridades de formato que hacen que la dialéctica posterior sea molesta.

Supongamos que está procesando texto enviado por un beneficiario y desea normalizarlo antiguamente de almacenarlo o compararlo. Tus reglas son:

• Eliminar espacios en blanco iniciales y finales

• Reemplace múltiples espacios, tabulaciones o nuevas líneas con un solo espacio

• Eliminar caracteres no alfanuméricos (excepto espacios)

• Convertir todo a minúsculas

sin usar reun enfoque distintivo podría hallarse así:

def clean_text(text):
    text = text.strip()
    text = text.replace("n", " ").replace("t", " ")
    
    while "  " in text:
        text = text.replace("  ", " ")
    
    cleaned = ()
    for char in text:
        if char.isalnum() or char == " ":
            cleaned.append(char)

    return "".join(cleaned).lower()

Esto no es terrible, pero es ruidoso. La intención se distribuye en bucles y operaciones repetidas. Y si desea modificar las reglas, volverá a editar varias líneas.

Con Python re.sub()puedes describir patrones de desorden en superficie de manejarlos un caso a la vez.

import re

def clean_text(text):
    text = re.sub(r"s+", " ", text) # normalize whitespace
    text = re.sub(r"(^a-zA-Z0-9 )", "", text) # remove punctuation
    return text.strip().lower()

Ésa es la misma dialéctica, expresada mucho más claramente.

Relacionado

7 formas efectos de manipular un archivo de texto con Python

Deja de pelear con tus archivos y usa Python para completar todas las tareas mundanas.

Búsqueda y reemplazo inteligentes

Todo programador de Python lo sabe str.replace(). Es simple, rápido y perfectamente correcto, hasta que necesitas contexto. El momento en que tu reemplazo depende de dónde aparece poco, lo que lo rodea o parte de lo que emparejaste, str.replace() se queda sin fuerza.

Imagine que está trabajando con registros o datos exportados que contienen información confidencial y desea encubrir las direcciones de correo electrónico antiguamente de juntar o compartir el archivo.

User john.doe@example.com logged in from 10.0.0.5

Quieres esto:

User ***@example.com logged in from 10.0.0.5

Usando métodos de sujeción básicos, esto rápidamente se vuelve incómodo:

def mask_email(text):
    words = text.split()
    masked = ()

    for word in words:
        if "@" in word:
            username, domain = word.split("@", 1)
            masked.append("***@" + domain)
        else:
            masked.append(word)

    return " ".join(masked)

Esto supone que los correos electrónicos están separados por espacios, no manejan correctamente la puntuación y combinan el examen con la dialéctica de reemplazo. Con re.sub()puede hacer coincidir las direcciones de correo electrónico directamente y reemplazar solo la parte que le interesa.

import re

EMAIL_PATTERN = re.compile(r"((w.-)+)@((w.-)+.w+)")

def mask_emails(text):
    return EMAIL_PATTERN.sub(r"***@2", text)

Aquí, Python re El módulo hace el trabajo pesado. El patrón encuentra cadenas similares a correos electrónicos en cualquier parte del texto, los grupos de captura aíslan el nombre de beneficiario y el dominio, y el reemplazo reutiliza parte de la coincidencia a través de 2. Esto es despabilarse y reemplazar con conciencia.

Analizar datos semiestructurados

Incluso en una situación de hornacina en la que algunos datos no están claramente estructurados y en forma completamente redimido, Python re El módulo silenciosamente salva el día. Supongamos que le dan cadenas como esta:

name=John age=32 role=admin active=true

Tu objetivo es convertir eso en un diccionario. El formato es coherente, pero no hay garantías sobre el esparcido, el orden o las claves que aparecen. Simplemente sabes que es una secuencia de pares clave-valor. Como primer intento, podrías apelar a split():

def parse_kv_string(text):
    result = {}
    parts = text.split()

    for part in parts:
        if "=" not in part:
            continue
        key, value = part.split("=", 1)
        result(key) = value

    return result

Esto funciona hasta que los títulos se vuelven más complejos, el esparcido cambia o desea potencia. Una vez más, la dialéctica para encontrar los datos y procesarlos está estrechamente relacionada.

Con Python re.findall()puede describir la estructura directamente y dejar que el motor realice el escaneo.

import re

KV_PATTERN = re.compile(r"(w+)=((^s)+)")

def parse_kv_string(text):
    return dict(KV_PATTERN.findall(text))

Ese patrón único expresa todo el formato: una esencia similar a una palabra, seguida del signo igual (=), seguida de un valencia que no es un espacio en blanco. pitón re El módulo extrae todos los pares en una sola pasada.

Relacionado

8 usos prácticos del módulo del sistema activo Python

Construyendo el puente entre Python y su sistema activo.

Si eres un programador de Python que ha estado evitando las expresiones regulares, empieza poco a poco. Usar re.fullmatch() para potencia. Intentar re.sub() la próxima vez que limpie el texto. Una vez que los patrones hagan clic, se encontrará escribiendo guiones más cortos que hacen más.