Torne os scripts Python mais inteligentes com regex: 5 exemplos práticos

Se você trabalha com strings em seus scripts Python e está escrevendo uma lógica obscura para processá-las, então você precisa examinar regex em Python. Ele permite descrever padrões em vez de escrever lógica processual. Vejamos alguns exemplos do mundo real onde o Python re módulo torna os scripts mais inteligentes.

Valide entradas sorrateiras do usuário

Ao validar a entrada do usuário sem regex, você provavelmente escreveu um código que parecia errado. Suponha que você queira validar um nome de usuário com estas regras:

• Apenas letras, números e sublinhados
• Deve começar com uma letra
• Comprimento entre 3 e 16 caracteres

Este é um requisito comum. Vamos ver o que você precisa fazer sem 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

Isso funciona,​​​​ mas é detalhado, fácil de bagunçar e cada nova regra significa adicionar mais lógica. É exatamente aí que o re módulo brilha. Você descreve as regras declarativamente usando re.compile() e use esse padrão em todos os lugares:

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)) 

Vamos entender o que está acontecendo.

• ^: Isso indica o início da string
• [a-zA-Z]: Deve começar com uma letra
• [a-zA-Z0-9_]{2,15}: Os caracteres permitidos e o comprimento restante
• $: Isso indica o fim da string

Depois de começar a validar entradas com refica difícil voltar atrás. Você expressa as regras diretamente e o Python faz o trabalho pesado.

Extraia dados de texto confuso

Em algum momento, todo script Python se transforma em um texto confuso. Arquivos de log, capturas de pacotes, e-mails, HTML copiado, entre outros. O desafio é criar essa estrutura sem escrever código de análise frágil, linha por linha.

Imagine que você está processando um arquivo de log de um aplicativo e deseja extrair carimbos de data/hora e mensagens de erro. Uma linha de log típica pode ser assim:

[2025-01-02 14:33:21] ERROR: Connection timed out after 30 seconds

Você pode tentar assim:

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

Isso funciona exatamente para o formato que você testou. Mas é frágil. Espaços extras, colchetes ausentes ou palavras ligeiramente diferentes podem quebrar a lógica. Além disso, a intenção do código está enterrada na ginástica de cordas. Com o re módulo, você pode descrever a estrutura da linha em vez de cortá-la 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") 

Aqui, dizemos ao Python exatamente o que estamos procurando: um carimbo de data/hora entre colchetes, seguido pela palavra “ERRO”, seguido pelo resto da mensagem.

Limpe e normalize o texto em uma linha

A limpeza de texto é uma daquelas tarefas que parece simples até que você realmente a execute. Freqüentemente, você precisa lidar com espaços em branco extras, separadores inconsistentes, pontuação aleatória ou peculiaridades de formatação que tornam a lógica posterior irritante.

Digamos que você esteja processando um texto enviado pelo usuário e queira normalizá-lo antes de armazená-lo ou compará-lo. Suas regras são:

• Remover espaços em branco à esquerda e à direita
• Substitua vários espaços, tabulações ou novas linhas por um único espaço
• Remova caracteres não alfanuméricos (exceto espaços)
• Converta tudo para letras minúsculas

Sem usar reuma abordagem típica pode ser assim:

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()

Isso não é terrível, mas é barulhento. A intenção está espalhada por loops e operações repetidas. E se quiser ajustar as regras, você voltará a editar várias linhas.

Com Python re.sub()você pode descrever padrões de bagunça em vez de lidar com eles um caso de cada 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()

Essa é a mesma lógica, expressada com muito mais clareza.

Localizar e substituir inteligente

Todo programador Python sabe str.replace(). É simples, rápido e perfeitamente adequado, até que você precise de contexto. O momento em que sua substituição depende de onde algo aparece, do que o rodeia ou de parte do que você combinou, str.replace() fica sem vapor.

Imagine que você está trabalhando com registros ou dados exportados que contêm informações confidenciais e deseja mascarar endereços de e-mail antes de armazenar ou compartilhar o arquivo.

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

Você quer isso:

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

Usando métodos básicos de string, isso rapidamente fica estranho:

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) 

Isso pressupõe que os e-mails são separados por espaço, não lidam bem com a pontuação e misturam análise com lógica de substituição. Com re.sub()você pode combinar endereços de e-mail diretamente e substituir apenas a parte de seu interesse.

import re  EMAIL_PATTERN = re.compile(r"([w.-]+)@([w.-]+.w+)")  def mask_emails(text):     return EMAIL_PATTERN.sub(r"***@2", text)

Aqui, Python re módulo faz o trabalho pesado. O padrão encontra strings semelhantes a e-mail em qualquer lugar do texto, os grupos de captura isolam o nome de usuário e o domínio e a substituição reutiliza parte da correspondência por meio de 2. Isso é encontrar e substituir com consciência.

Analisar dados semiestruturados

Mesmo em uma situação de nicho, quando alguns dados não estão estruturados de forma limpa e em formato totalmente livre, o Python re módulo silenciosamente salva o dia. Suponha que você receba strings como esta:

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

Seu objetivo é transformar isso em um dicionário. O formato é consistente, mas não há garantias sobre espaçamento, ordem ou quais chaves aparecem. Você apenas sabe que é uma sequência de pares de valores-chave. Como primeira tentativa, você pode tentar 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

Isso funciona até que os valores se tornem mais complexos, o espaçamento seja alterado ou você queira validação. Mais uma vez, a lógica para encontrar os dados e processá-los está fortemente interligada.

Com Python re.findall()você pode descrever a estrutura diretamente e deixar o mecanismo fazer a varredura.

import re  KV_PATTERN = re.compile(r"(w+)=([^s]+)")  def parse_kv_string(text):     return dict(KV_PATTERN.findall(text))

Esse padrão único expressa todo o formato: uma chave semelhante a uma palavra, seguida pelo sinal de igual (=), seguida por um valor sem espaço em branco. Python re módulo extrai todos os pares em uma passagem.

Se você é um programador Python que evita regex, comece aos poucos. Usar re.fullmatch() para validação. Tentar re.sub() na próxima vez que você estiver limpando o texto. Assim que os padrões clicarem, você se verá escrevendo scripts mais curtos que fazem mais.