Prática: validar e extrair

Validar um telefone brasileiro simples

Vamos validar um celular brasileiro em um formato comum: (11) 91234-5678. Ele tem um parêntese, dois dígitos de DDD, outro parêntese, um espaço, cinco dígitos, um hífen e quatro dígitos. Para descrever isso, montamos o padrão pedaço por pedaço. Como parênteses são especiais em regex, o parêntese literal do DDD precisa de barra: \( e \). O DDD são dois dígitos, \d{2}; depois \) e um espaço; então \d{5}, um hífen literal e \d{4}. Para validar, usamos re.fullmatch, que exige que todo o texto case, sem sobra.

import re

padrao = r"\(\d{2}\) \d{5}-\d{4}"

def telefone_valido(numero):
    return re.fullmatch(padrao, numero) is not None

print(telefone_valido("(11) 91234-5678"))  # True
print(telefone_valido("11912345678"))       # False (sem formatacao)
print(telefone_valido("(11) 1234-5678"))     # False (so 4 digitos no meio)
print(telefone_valido("ligar (11) 91234-5678 hoje"))  # False (tem texto em volta)

re.fullmatch exige que o texto inteiro siga o formato; is not None vira um True/False limpo.

Repare por que fullmatch é a escolha certa aqui. Se usássemos re.search, o último teste passaria, porque o número aparece no meio da frase e o search se contenta com um pedaço que casa. Para validação, queremos o texto inteiro no formato, e é exatamente isso que fullmatch garante. Outra opção equivalente seria envolver o padrão com as âncoras ^ e $ e usar search. As duas abordagens dizem a mesma coisa: o formato tem que valer do começo ao fim.

Capturar o DDD e o número

Validar é só o começo. Muitas vezes você também quer separar as partes do que validou, por exemplo guardar o DDD e o número em campos diferentes. Para isso servem os grupos de captura: você envolve o pedaço que interessa entre parênteses no padrão, e a regex guarda cada um separadamente. Depois de casar, .group(1) devolve o primeiro grupo, .group(2) o segundo, e assim por diante. O .group(0), ou .group() sem número, devolve o casamento inteiro.

import re

# Parenteses de captura em volta do DDD e do numero
padrao = r"\((\d{2})\) (\d{5}-\d{4})"

m = re.fullmatch(padrao, "(11) 91234-5678")
if m:
    print(m.group(0))  # (11) 91234-5678  (tudo)
    print(m.group(1))  # 11              (DDD)
    print(m.group(2))  # 91234-5678      (numero)

    ddd, numero = m.group(1), m.group(2)
    print(f"DDD {ddd}, numero {numero}")
    # DDD 11, numero 91234-5678

Parênteses no padrão criam grupos; .group(1) e .group(2) recuperam cada parte capturada.

Extrair todas as datas de um texto

O segundo desafio junta as duas metades do módulo: encontrar todas as datas escritas em um texto solto e transformar cada uma em objeto de data para poder calcular. Uma data no formato brasileiro tem dois dígitos, uma barra, dois dígitos, outra barra e quatro dígitos: \d{2}/\d{2}/\d{4}. Com re.findall, pegamos todas as ocorrências desse formato de uma vez, numa lista de textos. Em seguida, passamos cada texto por datetime.strptime para virar um objeto, pronto para comparações e cálculos da aula de datas.

import re
from datetime import datetime

texto = (
    "Reuniao em 02/07/2026, entrega em 15/08/2026 "
    "e revisao em 30/09/2026."
)

padrao = r"\d{2}/\d{2}/\d{4}"
encontradas = re.findall(padrao, texto)
print(encontradas)
# ['02/07/2026', '15/08/2026', '30/09/2026']

# Converter cada texto em objeto de data:
datas = [datetime.strptime(d, "%d/%m/%Y") for d in encontradas]
for d in datas:
    print(d.strftime("%d/%m/%Y"), "->", d.year)
# 02/07/2026 -> 2026
# 15/08/2026 -> 2026
# 30/09/2026 -> 2026

findall extrai os textos das datas; strptime, dentro da compreensão, converte cada um em objeto.

Esse pequeno programa mostra o encaixe perfeito dos dois temas do módulo. A regex reconhece a forma da data dentro de um texto bagunçado, algo que seria trabalhoso na mão. O tipo datetime transforma o texto em um valor com o qual dá para calcular: você poderia agora achar a data mais próxima, contar os dias até cada entrega ou ordenar as datas. Repare também no uso da compreensão de lista, do módulo 2, para converter todas as datas em uma linha. É o intermediário aparecendo: recursos diferentes se combinam para resolver um problema real com pouco código e muita clareza.

import re
from datetime import datetime, date

texto = "Prazos: 10/07/2026 e 05/07/2026."
datas = [
    datetime.strptime(d, "%d/%m/%Y").date()
    for d in re.findall(r"\d{2}/\d{2}/\d{4}", texto)
]

mais_cedo = min(datas)
hoje = date(2026, 7, 2)
print("Proximo prazo:", mais_cedo.strftime("%d/%m/%Y"))  # 05/07/2026
print("Faltam", (mais_cedo - hoje).days, "dias")          # Faltam 3 dias

Extrair, converter e calcular: encontrar o prazo mais próximo e contar os dias até ele.