Regex: O que É e Como Funciona | Python Brasil

import re

texto = 'Meu telefone e (11) 98765-4321 e meu email e ana@python.dev.br'

# re.search — encontra a PRIMEIRA ocorrencia
match = re.search(r'\d{5}-\d{4}', texto)
if match:
    print(match.group())  # 98765-4321
    print(match.start())  # posicao inicial
    print(match.end())    # posicao final

# re.findall — encontra TODAS as ocorrencias
numeros = re.findall(r'\d+', texto)
print(numeros)  # ['11', '98765', '4321']

# re.finditer — retorna iterador de objetos Match
for m in re.finditer(r'\d+', texto):
    print(f'{m.group()} na posicao {m.start()}')

# re.match — verifica apenas o INICIO da string
resultado = re.match(r'Meu', texto)
print(resultado.group())  # 'Meu'

# re.fullmatch — verifica se a string INTEIRA corresponde
print(re.fullmatch(r'\d+', '12345'))   # Match
print(re.fullmatch(r'\d+', '123abc'))  # None

# re.sub — substituicao
censurado = re.sub(r'\d', '*', texto)
print(censurado)  # 'Meu telefone e (**) *****-**** e meu email e ana@python.dev.br'

# re.split — dividir por padrao
partes = re.split(r'[,;\s]+', 'um, dois; tres    quatro')
print(partes)  # ['um', 'dois', 'tres', 'quatro']

import re

# . — qualquer caractere (exceto nova linha)
print(re.findall(r'P..hon', 'Python Pithon Pothon'))  # ['Python', 'Pithon', 'Pothon']

# \d — digito, \D — nao-digito
# \w — alfanumerico + _, \W — nao-alfanumerico
# \s — espaco em branco, \S — nao-espaco

# ^ — inicio da string, $ — final da string
print(re.search(r'^\d+', '123abc'))   # Match '123'
print(re.search(r'\d+$', 'abc123'))   # Match '123'

# Quantificadores
# * — zero ou mais
# + — um ou mais
# ? — zero ou um
# {n} — exatamente n
# {n,m} — de n a m

print(re.findall(r'\d{2,4}', 'a1 bc23 def456 ghij7890'))
# ['23', '456', '7890']

# Quantificadores preguicosos (lazy) vs gananciosos (greedy)
html = '<b>negrito</b> e <i>italico</i>'
print(re.findall(r'<.*>', html))    # ['<b>negrito</b> e <i>italico</i>'] — ganancioso
print(re.findall(r'<.*?>', html))   # ['<b>', '</b>', '<i>', '</i>'] — preguicoso

import re

# Colchetes definem classes de caracteres
print(re.findall(r'[aeiou]', 'Python Brasil'))  # vogais minusculas
print(re.findall(r'[A-Z]', 'Python Brasil'))    # letras maiusculas
print(re.findall(r'[0-9a-f]+', 'cor: #ff5733')) # hexadecimais

# Negacao com ^
print(re.findall(r'[^0-9]', 'abc123'))  # ['a', 'b', 'c']

# Alternativa com |
print(re.findall(r'gato|cachorro', 'Tenho um gato e um cachorro'))

import re

# Grupos com parenteses
texto = 'Nome: Ana Silva, Idade: 28'
match = re.search(r'Nome: (\w+ \w+), Idade: (\d+)', texto)
if match:
    print(match.group(0))  # 'Nome: Ana Silva, Idade: 28' — match completo
    print(match.group(1))  # 'Ana Silva'
    print(match.group(2))  # '28'
    print(match.groups())  # ('Ana Silva', '28')

# Grupos nomeados
padrao = r'(?P<nome>\w+ \w+).*?(?P<idade>\d+)'
match = re.search(padrao, texto)
if match:
    print(match.group('nome'))   # 'Ana Silva'
    print(match.group('idade'))  # '28'
    print(match.groupdict())     # {'nome': 'Ana Silva', 'idade': '28'}

# Grupo nao-capturante
resultado = re.findall(r'(?:https?://)?(\w+\.com\.br)', 'Acesse https://python.com.br')
print(resultado)  # ['python.com.br']

# Backreference
duplicadas = re.findall(r'\b(\w+)\s+\1\b', 'o o gato gato sentou')
print(duplicadas)  # ['o', 'gato']

import re

# Compilando padrao
padrao_email = re.compile(r'[\w.+-]+@[\w-]+\.[\w.]+')

emails = [
    'ana@email.com',
    'invalido@',
    'bruno.silva@empresa.com.br',
    'nao-email',
]

for e in emails:
    if padrao_email.fullmatch(e):
        print(f'Valido: {e}')
    else:
        print(f'Invalido: {e}')

# Flags de compilacao
padrao = re.compile(r'python', re.IGNORECASE)
print(padrao.findall('Python PYTHON python'))  # ['Python', 'PYTHON', 'python']

# Flag VERBOSE para padroes legiveis
padrao_cpf = re.compile(r"""
    ^\d{3}      # tres primeiros digitos
    \.          # ponto literal
    \d{3}       # tres digitos do meio
    \.          # ponto literal
    \d{3}       # tres ultimos digitos
    -           # hifen
    \d{2}$      # digitos verificadores
""", re.VERBOSE)

import re

def validar_cpf_formato(cpf: str) -> bool:
    """Valida o formato do CPF (nao verifica digitos)."""
    return bool(re.fullmatch(r'\d{3}\.\d{3}\.\d{3}-\d{2}', cpf))

def validar_telefone(telefone: str) -> bool:
    """Valida telefone brasileiro com DDD."""
    padrao = r'\(?\d{2}\)?\s?\d{4,5}-?\d{4}'
    return bool(re.fullmatch(padrao, telefone))

def extrair_hashtags(texto: str) -> list[str]:
    """Extrai hashtags de um texto."""
    return re.findall(r'#(\w+)', texto)

# Substituicao com funcao
def censurar_emails(texto: str) -> str:
    def ocultar(match):
        email = match.group()
        usuario, dominio = email.split('@')
        return f'{usuario[0]}***@{dominio}'
    return re.sub(r'[\w.+-]+@[\w-]+\.[\w.]+', ocultar, texto)

print(censurar_emails('Contato: ana.silva@email.com'))
# 'Contato: a***@email.com'