Desafio: hora da prática - exceções

# APLICANDO
5. gabarito = ['D', 'A', 'B', 'C', 'A']
testes_sem_ex = [['D', 'A', 'B', 'C', 'A'], ['C', 'A', 'A', 'C', 'A'], ['D', 'B', 'A', 'C', 'A']]
testes_com_ex = [['D', 'A', 'B', 'C', 'A'], ['C', 'A', 'A', 'E', 'A'], ['D', 'B', 'A', 'C', 'A']]
def calcular_notas(testes, gabarito):
    try:
        for estudante in testes:
            for resposta in estudante:
                if resposta not in ["A", "B", "C", "D"]:
                    raise ValueError(f"A alternativa {resposta} não é uma opção de alternativa válida.")
        notas_finas = []
        for estudante in testes:
            nota = 0
            for resposta, correta in zip(estudante, gabarito):
                if resposta == correta:
                    nota += 1
            notas_finas.append(nota)
        return notas_finas
    except ValueError as erro:
        return erro
print("Notas sem exceção: ")
resultado_erro = calcular_notas(testes_sem_ex, gabarito)
print(f"Resultado: {resultado_erro}")
print("\n")
print("Notas com exceção: ")
resultado_erro = calcular_notas(testes_com_ex, gabarito)
print(f"Resultado: {resultado_erro}")

6. lista_tratada = ['Python', 'é', 'uma', 'linguagem', 'de', 'programação', 'poderosa', 'versátil',
                  'e', 'fácil', 'de', 'aprender', 'utilizada', 'em', 'diversos', 'campos', 'desde',
                  'análise', 'de', 'dados', 'até', 'inteligência', 'artificial']
lista_nao_tratada = ['Python', 'é', 'uma', 'linguagem', 'de', 'programação', 'poderosa,', 'versátil',
                  'e', 'fácil,', 'de', 'aprender', 'utilizada', 'em', 'diversos', 'campos,', 'desde',
                  'análise', 'de', 'dados', 'até', 'inteligência', 'artificial!']
def avaliar_texto(lista):
    try:
        for palavra in lista:
            if "," in palavra or "." in palavra or "!" in palavra or "?" in palavra:
                raise ValueError(f"O texto apresenta pontuação na palavra '{palavra}'.")
        return "Texto tratado!"
    except ValueError as erro:
        return str(erro)
print("Lista tratada: ")
print(avaliar_texto(lista_tratada))
print("\n")
print("Lista não tratada: ")
print(avaliar_texto(lista_nao_tratada))

7. # DADOS SEM EXCEÇÃO
pressoes = [100, 120, 140, 160, 180]
temperaturas = [20, 25, 30, 35, 40]
# DADOS COM EXCEÇÃO
#1. ZERO
pressoes_zero = [60, 120, 140, 160, 180]
temperaturas_zero = [0, 25, 30, 35, 40]
# 2. VALUE
pressoes_value = [100, 120, 140, 160]
temperaturas_value = [20, 25, 30, 35, 40]

def colunas(pressoes, temperaturas):
    try:
        if len(pressoes) != len(temperaturas):
            raise ValueError(f"A quantidade de elementos nas listas de pressões e temperatura são diferentes.")
        resultado = []
        for p, t in zip(pressoes, temperaturas):
            razao = p / t
            resultado.append(razao)
        return resultado
    except ValueError as erro:
        return f"Value Error: {erro}"
    except ZeroDivisionError as erro:
        return f"ZeroDivisonError: Divisão por zero detectada no experimento: {erro}"
print("Sem exceção: ")
print(f"Resultado: {colunas(pressoes, temperaturas)}")
print("\n")
print("Com exceção zero: ")
print(f"Resultado: {colunas(pressoes_zero, temperaturas_zero)}")
print("\n")
print("Com exceção value: ")
print(f"Resultado: {colunas(pressoes_value, temperaturas_value)}")

Olá, Luísa. Como vai?

A segunda parte dos seus exercícios manteve o mesmo altíssimo nível técnico. Você construiu códigos limpos e aplicou com maestria o lançamento de exceções customizadas com o raise — uma postura essencial em Data Science para lidar com dados brutos "sujos".

Destaque para a validação defensiva no Exercício 5 (varrer a lista antes de computar as notas), a higienização de strings no Exercício 6 e o tratamento duplo (ValueError e ZeroDivisionError) no Exercício 7.

Respondendo à sua dúvida (Exercício 2)

Dúvida: qual método uso para o sistema aceitar "Júlia" sem acento?

Para isso, fazemos a normalização de strings para remover os acentos tanto da busca do usuário quanto das chaves do dicionário antes da comparação. A forma padrão ouro em Python é usar o módulo nativo unicodedata.

O método unicodedata.normalize('NFD', texto) decompõe os caracteres acentuados (separa a letra do acento). Depois, usamos .encode('ascii', 'ignore') para descartar o que não for ASCII puro (os acentos), sobrando apenas as letras limpas.

Como aplicar no seu código:

Criamos uma função auxiliar de limpeza e a aplicamos no dicionário e na busca:

import unicodedata

def remover_acentos(texto):
    texto_normalizado = unicodedata.normalize('NFD', texto)
    return texto_normalizado.encode('ascii', 'ignore').decode('utf-8').title()

# 1. Criamos o dicionário aplicando a limpeza nas chaves
idades_original = {'Júlia': 16, 'Carol': 23, 'Alberto': 19, 'Roberta': 17}
idades = {remover_acentos(nome): idade for nome, idade in idades_original.items()}

try:
    nome_pesquisa = input("Digite o nome para pesquisar a idade: ")
    nome_limpo = remover_acentos(nome_pesquisa)
    
    idade = idades[nome_limpo]
    print(f"A idade de {nome_pesquisa.title()} é {idade} anos.")
except KeyError:
    print("Nome não encontrado")

Agora, se o usuário digitar "júlia", "Julia" ou "JULIA", o sistema converterá tudo para "Julia" e a busca funcionará perfeitamente.

Duas Dicas de Ouro para Otimizar seus Códigos

Para o universo de Data Science, veja como reescrever os exercícios 5 e 6 usando recursos nativos que deixam o código mais performático e elegante:

1. No Exercício 5 (Otimizando com o any())

Em vez de loops for aninhados para caçar erros, use a função nativa any() com compreensão de lista. Para o cálculo das notas, podemos usar o fato de que, em Python, True vale 1 e False vale 0:

def calcular_notas(testes, gabarito):
    try:
        # Validação expressa de erro
        if any(resposta not in ["A", "B", "C", "D"] for estudante in testes for resposta in estudante):
            for estudante in testes:
                for resposta in estudante:
                    if resposta not in ["A", "B", "C", "D"]:
                        raise ValueError(f"A alternativa {resposta} não é uma opção válida.")
        
        # Cálculo direto: somar True (1) e False (0)
        return [sum(r == c for r, c in zip(estudante, gabarito)) for estudante in testes]
    except ValueError as erro:
        return erro

2. No Exercício 6 (Usando a biblioteca string)

Evite digitar as pontuações manualmente. O módulo nativo string possui a constante string.punctuation, que já carrega todos os sinais existentes no teclado:

import string

def avaliar_texto(lista):
    try:
        for palavra in lista:
            # string.punctuation contém todos os símbolos (!, ?, ., ,, etc.)
            if any(caractere in string.punctuation for caractere in palavra):
                raise ValueError(f"O texto apresenta pontuação na palavra '{palavra}'.")
        return "Texto tratado!"
    except ValueError as erro:
        return str(erro)

Pequenos detalhes de digitação:

• No Exercício 5, você escreveu notas_finas = [] em vez de notas_finais = [].
• No Exercício 7, no except, mudou para ZeroDivisonError (faltou o "i" em Division no texto impresso).

Parabéns pelo excelente progresso e dedicação nos estudos de Python para Dados!

Espero que possa ter lhe ajudado!