Validar, limpar e
formatar texto

def sanitizar_email(bruto):
    """Remove espaços e padroniza a caixa do e-mail."""
    return bruto.strip().replace(" ", "").lower()


def so_digitos(texto):
    """Devolve apenas os algarismos do texto."""
    saida = ""
    for c in texto:
        if c.isdigit():
            saida += c
    return saida

>>> sanitizar_email("  ANA @Escola.COM ")
'ana@escola.com'

>>> so_digitos("(11) 98765-4321")
'11987654321'

>>> so_digitos("123.456.789-00")
'12345678900'

def senha_forte(senha):
    """
    Verifica se a senha atende à política mínima.

    Args:
        senha (str): senha digitada pelo usuário.

    Returns:
        bool: True se tem 8+ caracteres, ao menos
              uma maiúscula, uma minúscula e um dígito.
    """
    if len(senha) < 8:
        return False

    tem_maiuscula = False
    tem_minuscula = False
    tem_digito = False

    for c in senha:
        if c.isupper():
            tem_maiuscula = True
        elif c.islower():
            tem_minuscula = True
        elif c.isdigit():
            tem_digito = True

    return tem_maiuscula and tem_minuscula and tem_digito

>>> senha_forte("escola")
False   (curta demais)

>>> senha_forte("escola2026")
False   (sem maiúscula)

>>> senha_forte("Escola2026")
True

def email_valido(email):
    """Aplica as regras mínimas de formato de e-mail."""
    email = email.strip().lower()

    if email.count("@") != 1:
        return False

    usuario, dominio = email.split("@")

    if len(usuario) == 0 or len(dominio) == 0:
        return False
    if "." not in dominio:
        return False
    if " " in email:
        return False

    return True

Casos de teste que importam

def cpf_formato_ok(cpf):
    """
    Verifica o formato do CPF (não os dígitos
    verificadores): 11 algarismos, não todos iguais.
    """
    numeros = so_digitos(cpf)

    if len(numeros) != 11:
        return False
    if numeros == numeros[0] * 11:
        return False

    return True

>>> cpf_formato_ok("123.456.789-00")
True
>>> cpf_formato_ok("111.111.111-11")
False
>>> cpf_formato_ok("123456789")
False

Armazenado
11987654321
1234.5
7
2026-09-11

Exibido
(11) 98765-4321
R$ 1.234,50
Nota 07
11/09/2026

linhas = [
    "Ana Silva;8.5;9.0;7.5",
    "Bruno Costa;6.0;7.5;8.0",
    "Carla Dias;9.5;9.0;10.0",
]

for linha in linhas:
    campos = linha.split(";")
    nome = campos[0]
    notas = [float(n) for n in campos[1:]]
    media = sum(notas) / len(notas)
    print(f"{nome:<15} média {media:.2f}")

Ana Silva       média 8.33
Bruno Costa     média 7.17
Carla Dias      média 9.50

def formatar_telefone(numero):
    """
    Aplica a máscara (DD) 9NNNN-NNNN.

    Args:
        numero (str): telefone com ou sem pontuação.

    Returns:
        str: telefone mascarado, ou o valor limpo
             se não tiver 11 dígitos.
    """
    d = so_digitos(numero)

    if len(d) != 11:
        return d

    return f"({d[:2]}) {d[2:7]}-{d[7:]}"

>>> formatar_telefone("11987654321")
'(11) 98765-4321'

>>> formatar_telefone("(11) 9 8765 4321")
'(11) 98765-4321'

>>> formatar_telefone("1198765")
'1198765'

alunos = [("Ana Silva", 8.33), ("Bruno Costa", 7.17),
          ("Carla Dias", 9.5)]

print("=" * 34)
print(f"{'ALUNO':<20}{'MÉDIA':>8}{'SIT':>6}")
print("=" * 34)

for nome, media in alunos:
    situacao = "APR" if media >= 6 else "REC"
    print(f"{nome:<20}{media:>8.2f}{situacao:>6}")

print("-" * 34)
print(f"{'TOTAL':<20}{len(alunos):>8}")

==================================
ALUNO                  MÉDIA   SIT
==================================
Ana Silva               8.33   APR
Bruno Costa             7.17   APR
Carla Dias              9.50   APR
----------------------------------
TOTAL                      3

def testar_email_valido():
    # Arrange — casos e gabaritos escritos na mão
    casos = [
        ("ana@escola.com",  True),   # caminho feliz
        ("  ANA@Escola.com ", True), # sanitização
        ("ana@escola",      False),  # sem ponto
        ("@escola.com",     False),  # sem usuário
        ("a@@b.com",        False),  # dois arrobas
        ("",                False),  # borda: vazio
    ]

    for entrada, esperado in casos:
        # Act
        obtido = email_valido(entrada)
        # Assert
        assert obtido == esperado, \
            f"{entrada!r}: esperado {esperado}, veio {obtido}"

    print("OK: email_valido")

testar_email_valido()

OK: email_valido