2

Capítulo 1: Sintaxe

Capítulo 3: Tratamento de erros e exceções

O tratamento de erros e exceções é uma parte importante da
programação em Python e é essencial para lidar com situações
inesperadas que podem ocorrer durante a execução de um programa.
Neste capítulo, vamos explorar alguns dos erros e exceções mais
comuns em Python e como tratá-los adequadamente.
ZeroDivisionError
O erro ZeroDivisionError é gerado quando tentamos dividir um
número por zero. Esse erro pode ser evitado verificando se o
denominador é diferente de zero antes de realizar a divisão. Por
exemplo:
pythonCopy code
try: resultado = 10 / 0 except ZeroDivisionError: print("Não é
possível dividir por zero.")
RecursionError
O erro RecursionError ocorre quando uma função é chamada
recursivamente muitas vezes, o que pode levar a um estouro de pilha.
Para evitar esse erro, é necessário revisar a lógica da função e
garantir que a recursão tenha uma condição de parada adequada. Por
exemplo:
pythonCopy code
def fatorial(n): if n == 0: return 1 else: return n * fatorial(n-1) try:
resultado = fatorial(1000) except RecursionError: print("Ocorreu um
estouro de pilha.")
SystemError
O erro SystemError é gerado quando ocorre uma falha interna no
interpretador Python. Geralmente, não há muito o que possamos
2
Capítulo 1: Sintaxe

fazer para corrigir esse erro, além de relatar o problema aos

desenvolvedores do Python. Por exemplo:
pythonCopy code
try: # código que pode causar um SystemError except SystemError
as e: print(f"Ocorreu um erro interno do Python: {e}")
AssertionError
O erro AssertionError ocorre quando uma expressão condicional em
uma instrução assert é avaliada como falsa. Essa instrução é útil para
verificar suposições em tempo de execução e pode ser usada para
validar entradas ou saídas de funções. Por exemplo:
pythonCopy code
def soma(a, b): assert isinstance(a, int) and isinstance(b, int), "Os
argumentos devem ser inteiros." return a + b try: resultado =
soma(10, "20") except AssertionError as e: print(f"Ocorreu um erro
de assert: {e}")
NotImplementedError
O erro NotImplementedError é gerado quando uma classe define um
método abstrato, mas não o implementa. Esse erro pode ser corrigido
implementando o método na classe ou marcando-o como abstrato.
Por exemplo:
pythonCopy code
from abc import ABC, abstractmethod class Animal(ABC):
@abstractmethod def fazer_som(self): raise
NotImplementedError("O método fazer_som deve ser
implementado.") class Cachorro(Animal): def fazer_som(self):
print("Au au!") animal = Animal() # gera um NotImplementedError
cachorro = Cachorro() # não gera erro cachorro.fazer_som() #
imprime "Au au!"
2
Capítulo 1: Sintaxe

Com este capítulo, agora você tem uma boa compreensão dos erros e
exceções mais comuns em Python e como tratá-los adequadamente.
No próximo capítulo, vamos explorar como

O tratamento de erros e exceções é uma técnica importante na

programação que permite aos desenvolvedores lidar com problemas
inesperados em seus programas de maneira mais eficiente. Em
Python, a abordagem para o tratamento de erros e exceções é feita
por meio de blocos try/except.
Diferentemente dos erros discutidos nos capítulos anteriores, os erros
tratados neste capítulo são do tipo "runtime" e geralmente ocorrem
quando o programa está em execução. Aqui estão alguns dos erros
mais comuns:
Capítulo 3: Tratamento de erros e exceções
O tratamento de erros e exceções é uma parte importante da
programação em Python e é essencial para lidar com situações
inesperadas que podem ocorrer durante a execução de um programa.
Neste capítulo, vamos explorar alguns dos erros e exceções mais
comuns em Python e como tratá-los adequadamente.
ZeroDivisionError
O erro ZeroDivisionError é gerado quando tentamos dividir um
número por zero. Esse erro pode ser evitado verificando se o
denominador é diferente de zero antes de realizar a divisão. Por
exemplo:
pythonCopy code
try: resultado = 10 / 0 except ZeroDivisionError: print("Não é
possível dividir por zero.")
RecursionError
O erro RecursionError ocorre quando uma função é chamada
recursivamente muitas vezes, o que pode levar a um estouro de pilha.
2
Capítulo 1: Sintaxe

Para evitar esse erro, é necessário revisar a lógica da função e

garantir que a recursão tenha uma condição de parada adequada. Por
exemplo:
pythonCopy code
def fatorial(n): if n == 0: return 1 else: return n * fatorial(n-1) try:
resultado = fatorial(1000) except RecursionError: print("Ocorreu um
estouro de pilha.")
SystemError
O erro SystemError é gerado quando ocorre uma falha interna no
interpretador Python. Geralmente, não há muito o que possamos
fazer para corrigir esse erro, além de relatar o problema aos
desenvolvedores do Python. Por exemplo:
pythonCopy code
try: # código que pode causar um SystemError except SystemError
as e: print(f"Ocorreu um erro interno do Python: {e}")
AssertionError
O erro AssertionError ocorre quando uma expressão condicional em
uma instrução assert é avaliada como falsa. Essa instrução é útil para
verificar suposições em tempo de execução e pode ser usada para
validar entradas ou saídas de funções. Por exemplo:
pythonCopy code
def soma(a, b): assert isinstance(a, int) and isinstance(b, int), "Os
argumentos devem ser inteiros." return a + b try: resultado =
soma(10, "20") except AssertionError as e: print(f"Ocorreu um erro
de assert: {e}")
NotImplementedError
O erro NotImplementedError é gerado quando uma classe define um
método abstrato, mas não o implementa. Esse erro pode ser corrigido
implementando o método na classe ou marcando-o como abstrato.
Por exemplo:
2
Capítulo 1: Sintaxe

pythonCopy code
from abc import ABC, abstractmethod class Animal(ABC):
@abstractmethod def fazer_som(self): raise
NotImplementedError("O método fazer_som deve ser
implementado.") class Cachorro(Animal): def fazer_som(self):
print("Au au!") animal = Animal() # gera um NotImplementedError
cachorro = Cachorro() # não gera erro cachorro.fazer_som() #
imprime "Au au!"
Com este capítulo, agora você tem uma boa compreensão dos erros e
exceções mais comuns em Python e como tratá-los adequadamente.
No próximo capítulo, vamos explorar como

Capítulo 3 - Tratamento de erros e exceções

Ao escrever programas em Python, é comum encontrarmos erros que
podem prejudicar o funcionamento adequado do programa. Erros
podem ser causados por diversas razões, incluindo entrada incorreta
de dados, problemas com arquivos e diretórios, entre outros.
Felizmente, a linguagem Python possui recursos para lidar com erros
e exceções de maneira eficiente, permitindo que os desenvolvedores
identifiquem, relatem e corrijam problemas com mais facilidade.
Neste capítulo, vamos explorar os principais erros de tratamento de
exceções em Python.
ZeroDivisionError
O erro ZeroDivisionError é gerado quando tentamos dividir um
número por zero. Por exemplo:
makefileCopy code
x = 10 y = 0 z = x/y
Esse código gerará o seguinte erro:
vbnetCopy code
ZeroDivisionError: division by zero
2
Capítulo 1: Sintaxe

Para corrigir esse erro, podemos adicionar um tratamento de exceção

para detectar quando a divisão por zero ocorre. Por exemplo:
pythonCopy code
x = 10 y = 0 try: z = x/y except ZeroDivisionError: print("Erro:
Divisão por zero.")
RecursionError
RecursionError é gerado quando uma função chama a si mesma
repetidamente, resultando em um estouro de pilha. Por exemplo:
scssCopy code
def contagem_regressiva(n): print(n) contagem_regressiva(n-1)
contagem_regressiva(10)
Esse código gerará o seguinte erro:
vbnetCopy code
RecursionError: maximum recursion depth exceeded while calling a
Python object
Para corrigir esse erro, é necessário garantir que a função não seja
chamada recursivamente muitas vezes. Isso pode ser feito definindo
uma condição de parada para a recursão, como por exemplo:
scssCopy code
def contagem_regressiva(n): if n == 0: return print(n)
contagem_regressiva(n-1) contagem_regressiva(10)
SystemError
SystemError é gerado quando ocorre um erro interno do
interpretador Python. Esse erro geralmente indica um bug no próprio
Python ou em uma extensão Python. Por exemplo:
scssCopy code
def minha_funcao(): return 1/0 for i in range(100): minha_funcao()
Esse código gerará o seguinte erro:
pythonCopy code
2
Capítulo 1: Sintaxe

SystemError: <class 'ZeroDivisionError'> returned a result with an

error set
Para corrigir esse erro, é necessário identificar e corrigir o erro
interno do interpretador Python ou da extensão Python que está
causando o erro.
AssertionError
AssertionError é gerado quando a expressão de uma instrução assert
é avaliada como falsa. Por exemplo:
pythonCopy code
x = 10 assert x == 5, "x deve ser igual a 5"
Esse código gerará o seguinte erro:
makefileCopy code
AssertionError: x deve ser igual a 5
Para corrigir esse erro, é necessário corrigir a expressão assert para
que ela seja avaliada como verdadeira ou remover a instrução assert.
Claro! O NotImplementedError é uma exceção que ocorre quando
uma classe ou método não implementou uma funcionalidade que é
esperada. Isso pode ocorrer quando uma funcionalidade é planejada,
mas ainda não foi implementada, ou quando uma funcionalidade é
considerada opcional em uma interface, mas não foi implementada
por uma classe que a implementa.
Por exemplo, se você estiver trabalhando em uma classe de
matemática e tiver uma função sqrt que calcula a raiz quadrada de
um número, você poderia implementá-la apenas para números
positivos, mas não para números negativos. Se você tentar calcular a
raiz quadrada de um número negativo, sua classe pode levantar uma
exceção NotImplementedError para indicar que essa funcionalidade
não foi implementada.
Para corrigir esse erro, você precisará implementar a funcionalidade
ausente. No exemplo acima, você poderia implementar a
2
Capítulo 1: Sintaxe

funcionalidade de calcular a raiz quadrada de números negativos

retornando um número complexo.
Em geral, a melhor forma de lidar com o NotImplementedError é
documentar claramente as limitações de uma classe ou método,
indicando quais funcionalidades ainda não foram implementadas.
Isso pode evitar que outros desenvolvedores tentem usar uma
funcionalidade que ainda não está disponível e acabem causando
exceções NotImplementedError.

NotImplementedError
O NotImplementedError é uma exceção que é gerada quando uma
funcionalidade ainda não foi implementada. Ele é frequentemente
usado para informar aos usuários que um recurso ainda não está
disponível.
Causas comuns:
Tentativa de chamar uma função que ainda não foi implementada;
Utilização de um método abstrato que não foi implementado;
Chamada a uma classe que ainda não foi implementada.
Como corrigir:
A solução mais simples para o NotImplementedError é implementar
a funcionalidade que está faltando. Se o erro ocorrer em uma
biblioteca de terceiros, talvez seja necessário aguardar uma
atualização ou encontrar uma alternativa. Em alguns casos, o
NotImplementedError pode ser usado propositalmente em uma
classe abstrata ou interface para informar aos desenvolvedores que a
funcionalidade precisa ser implementada por qualquer classe que a
herde.
É importante ressaltar que a utilização de NotImplementedError deve
ser evitada em situações onde a implementação da funcionalidade é
obrigatória para o correto funcionamento do programa. Nesses casos,
2
Capítulo 1: Sintaxe

é recomendado gerar uma exceção customizada para informar ao

usuário que a funcionalidade ainda não está disponível.
Claro! O NotImplementedError é gerado quando uma classe define
um método abstrato, mas não implementa o comportamento esperado
para esse método. Isso pode acontecer quando uma classe abstrata é
usada como um modelo para outras classes e essas outras classes são
obrigadas a implementar o método abstrato.
Por exemplo:
rubyCopy code
class Animal: def falar(self): raise NotImplementedError("Subclasses
devem implementar este método.")
Se uma subclasse de Animal não implementar o método falar(), será
gerado um erro de NotImplementedError ao tentar chamá-lo.
Para corrigir esse erro, é necessário que a subclasse implemente o
método falar(), fornecendo um comportamento adequado para a
classe em questão. Se for desejado que a subclasse não tenha um
comportamento específico para o método, é possível definir um
comportamento padrão na classe pai, ao invés de levantar um erro.

Certamente! O tratamento de erros e exceções é uma parte

fundamental da programação em Python. Saber como identificar e
lidar com erros é crucial para escrever código robusto e confiável.
Neste capítulo, discutimos vários erros comuns, incluindo
ZeroDivisionError, RecursionError, SystemError, AssertionError e
NotImplementedError.
Para cada um desses erros, explicamos suas possíveis causas e
fornecemos soluções para corrigi-los. É importante lembrar que,
embora possamos evitar muitos erros através da prática de boas
técnicas de programação, nem sempre é possível evitar todos os
2
Capítulo 1: Sintaxe

erros. Portanto, saber como lidar com erros é uma habilidade

fundamental para todo programador.
Ao entender como lidar com esses erros comuns, você estará melhor
preparado para depurar seu código e garantir que ele esteja
funcionando conforme o esperado. No próximo capítulo,
discutiremos como criar nossos próprios tipos de exceção
personalizados para lidar com erros específicos que podem surgir em
nossos programas.

Evitar fazer
divisões por
Tentativa
zero ou
ZeroDivisionError de divisão
adicionar
por zero
tratamento de
exceção

Reportar o
erro para os
Erro interno
desenvolvedor
do
SystemError es do Python
interpretado
ou atualizar a
r Python
versão do
interpretador
2
Capítulo 1: Sintaxe

Ajustar o
Recursão algoritmo
infinita ou para evitar a
profundidad recursão
RecursionError
e de infinita ou
recursão aumentar o
excedida limite de
profundidade

Tentativa Implementar a
de chamar função ou
uma função remover a
NotImplementedErr
que ainda chamada da
or
não foi função que
implementa ainda não foi
da implementada

Expressão Corrigir a
de assert expressão
AssertionError assert para
avaliada
como falsa que seja
avaliada como
2
Capítulo 1: Sintaxe

verdadeira ou
remover a
instrução