.jpg)
Seja muito bem-vindo à Academy Code Christ!
🌍 Academy Code Christ está disponível em vários idiomas.Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.
Python 🐍 Etapa 08
Tratamento de Erros
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
🎯 Erros fazem parte da programação
Primeiro, uma verdade simples:
Todo programador erra. Sempre.
Erros são parte natural do processo de aprendizado e
desenvolvimento.
Python nos ajuda muito, pois fornece
mensagens de erro detalhadas — o segredo é saber interpretá-las.
Existem dois grandes tipos de erros:
1. Erros de sintaxe (SyntaxError) – o Python nem consegue interpretar o código.
2. Erros de execução (Exceções) – o código é válido, mas algo inesperado ocorre durante a execução (ex: divisão por zero, arquivo inexistente, valor inválido).
Vamos ver cada tipo.
Erros de sintaxe
São problemas na escrita do código — algo que fere as regras da linguagem.
if True
print("Erro!") # Falta de dois-pontos
Mensagem no terminal:
File "exemplo.py", line 1
if True
^
SyntaxError: expected ':'
O Python informa onde e o que está errado.
Normalmente, erros desse tipo são
simples de resolver: fechar aspas, ajustar parênteses, identar corretamente ou
incluir : após blocos (if, for, def, etc).
Erros de execução (exceções)
Mesmo quando o código está sintaticamente correto, ele pode encontrar situações inesperadas.
Exemplo:
numero = int(input("Digite um número: "))
print(10 / numero)
Se o usuário digitar 0, o programa falhará com:
ZeroDivisionError: division by zero
Ou se digitar algo não numérico:
ValueError: invalid literal for int() with base 10: 'abc'
Essas são exceções — eventos que interrompem a execução normal do programa.
Lidando com exceções: try / except
Para evitar que o programa quebre, usamos o bloco try/except.
try:
numero = int(input("Digite um número: "))
resultado = 10 / numero
print("Resultado:", resultado)
except:
print("Ocorreu um erro!")
Agora o programa não cai abruptamente: ele tenta executar e, se algo falhar, executa o bloco alternativo.
Mas existe um detalhe importante — o ideal é tratar erros específicos, e não capturar todos de uma vez.
Tratando exceções específicas
Podemos prever diferentes erros e reagir de forma adequada.
try:
numero = int(input("Digite um número: "))
resultado = 10 / numero
print("Resultado:", resultado)
except ZeroDivisionError:
print("Erro: não é possível dividir por zero.")
except ValueError:
print("Erro: digite um número válido.")
Dessa forma, a mensagem exibida ao usuário é mais informativa e mantém o programa em funcionamento.
Capturando detalhes do erro
Podemos capturar o objeto da exceção para exibir detalhes técnicos.
try:
x = int(input("Número: "))
y = 10 / x
except Exception as erro:
print("Ocorreu um problema:", erro)
Saída:
Número: 0
Ocorreu um problema: division by zero
Isso é muito útil durante testes e depuração.
Usando else e finally
O bloco try aceita cláusulas complementares:
● else → executa se nenhum erro acontecer
● finally → executa sempre, com erro ou não (ótimo para fechar conexões ou liberar recursos)
Exemplo completo:
try:
n = int(input("Digite um número: "))
resultado = 10 / n
except ZeroDivisionError:
print("Divisão por zero não permitida.")
else:
print("Resultado:", resultado)
finally:
print("Execução encerrada.")
Saída possível:
Digite um número: 2
Resultado: 5.0
Execução encerrada.
Ou, se houver erro:
Digite um número: 0
Divisão por zero não permitida.
Execução encerrada.
Depurando código (“debug”)
Depurar é o ato de encontrar e corrigir erros lógicos
em um programa.
Python fornece várias ferramentas para
isso.
1. Usar print() com propósito
A forma mais simples e eficaz de depuração inicial.
Inserir print() nos pontos estratégicos mostra o estado das
variáveis.
def calcular_media(a, b):
print("[DEBUG] Entrou na função com a =", a, "e b =", b)
return (a + b) / 2
Embora simples, deve ser usada com moderação. Em projetos grandes, é melhor usar módulos específicos de logging (Capítulo 14).
2. Depurador do Visual
Studio Code ou IDLE
Ambientes modernos de desenvolvimento possuem depuradores que permitem:
● Colocar breakpoints (pausar a execução em um ponto);
● Visualizar variáveis em tempo real;
● Executar passo a passo (step over, step into);
● Inspecionar a pilha de chamadas (stack trace).
Essas ferramentas são ideais para investigar erros complexos e entender o fluxo detalhado do código.
3. Usar pdb (Python Debugger)
Python possui um depurador nativo no módulo pdb.
import pdb
def soma(a, b):
pdb.set_trace() # pausa a execução aqui
return a + b
print(soma(2, 3))
Quando o programa chega nessa linha, você entra em modo interativo para investigar as variáveis e o fluxo.
Erros lógicos: quando o código não quebra, mas está errado
Nem sempre o Python acusa erro. Às vezes, o programa roda “corretamente”, mas com resultados inesperados.
Exemplo:
def media(n1, n2):
return n1 + n2 / 2 # erro de lógica (sem parênteses)
print(media(8, 10))
Saída:
13.0
Mas o correto seria (8 + 10) / 2 = 9.
Esses erros são os mais difíceis — exigem atenção à lógica e precedência de operadores, além de testes e boas práticas.
Criando exceções personalizadas
Você pode criar os seus próprios tipos de erro com raise.
def dividir(a, b):
if b == 0:
raise ValueError("O denominador não pode ser zero!")
return a / b
try:
print(dividir(10, 0))
except ValueError as erro:
print("Erro personalizado:", erro)
Saída:
Erro personalizado: O denominador não pode ser zero!
Criar exceções próprias é útil em projetos grandes, onde diferentes módulos precisam sinalizar erros específicos.
Encadeando exceções (raise from)
Às vezes, queremos transformar um erro em outro, sem perder o
contexto original.
Para isso usamos raise … from.
try:
numero = int("abc") # gera ValueError
except ValueError as e:
raise RuntimeError("Erro ao converter número") from e
Python exibirá toda a cadeia de erros, ajudando na análise.
Registrando erros com o módulo logging
Para programas maiores, use logging em vez de muitos print().
import logging
logging.basicConfig(level=logging.INFO)
logging.info("Iniciando o programa...")
try:
resultado = 10 / 0
except Exception as e:
logging.error("Erro ocorreu: %s", e)
O logging permite gravar mensagens em arquivos, definir níveis (INFO, WARNING, ERROR) e filtrar saídas — uma prática profissional para rastrear problemas em produção.
Estratégias de prevenção de erros
1. Valide entradas
Sempre verifique se o valor recebido
é do tipo esperado.
Use .isdigit(), .isalpha(), entre outros.
2. Divida o código em funções pequenas
Mais fácil de testar e identificar
falhas.
3. Teste regularmente
Rodar trechos do código enquanto
desenvolve evita que pequenos erros cresçam.
4. Comente e documente
Entender “por que algo foi feito” é
tão importante quanto o código em si.
5. Preveja o pior
Tente imaginar tudo que poderia dar
errado — e trate essas situações com try/except.
Mini‑projetos práticos
1. Calculadora robusta
Aplicando tratamento de erros:
while True:
try:
x = float(input("Primeiro número: "))
y = float(input("Segundo número: "))
operacao = input("Operação (+, -, *, /) ou 'sair': ").strip()
if operacao == "sair":
break
elif operacao == "+":
print("Resultado:", x + y)
elif operacao == "-":
print("Resultado:", x - y)
elif operacao == "*":
print("Resultado:", x * y)
elif operacao == "/":
print("Resultado:", x / y)
else:
print("Operação inválida.")
except ZeroDivisionError:
print("Não é possível dividir por zero.")
except ValueError:
print("Digite apenas números válidos.")
2. Verificador de CPF
simplificado
Valida formato e comprimento do texto:
cpf = input("Digite o CPF (somente números): ").strip()
if not cpf.isdigit() or len(cpf) != 11:
raise ValueError("CPF inválido. Deve conter 11 dígitos numéricos.")
else:
print("CPF formatado com sucesso.")
Resumo
Nesta etapa, você aprendeu a:
✅ Reconhecer
erros de sintaxe e de execução.
✅ Usar try, except, else e finally para tratar exceções.
✅ Entender, depurar e capturar detalhes
de erros.
✅ Criar exceções personalizadas com raise.
✅ Utilizar logging para registrar e analisar
problemas.
✅ Aplicar boas práticas de validação e
prevenção.
Com essas habilidades, seus programas passam a ser robustos, confiáveis e resilientes — preparados para lidar com o inesperado sem causar travamentos.
👉 Na próxima etapa, daremos um passo natural: aprenderemos a organizar módulos e pacotes, entendendo como estruturar projetos maiores e reaproveitar código em múltiplos arquivos. Esse é o segredo dos projetos profissionais em Python.
.png)
.png)
Postar um comentário