Python Academy · Aula

Classes de exceção personalizadas

Defina seus próprios tipos de exceção para comunicar erros com mais clareza.

Classes de exceção personalizadas é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Introdução

Classes de exceção personalizadas tornam o tratamento de erros explícito, autoexplicativo e fácil de tratar com precisão por quem chama o código.

Por que usar exceções personalizadas?

As exceções integradas são genéricas demais. As exceções personalizadas permitem que quem chama o código capture apenas os erros da sua biblioteca, sem capturar erros não relacionados.

class AppError(Exception):
    pass
raise AppError('something went wrong')

Herdando de Exception

class MyError(Exception): pass é tudo de que você precisa. Sempre herde de Exception, não de BaseException.

class ValidationError(Exception):
    pass
try:
    raise ValidationError('email is invalid')
except ValidationError as e:
    print(e)

Adicionando atributos personalizados

class APIError(Exception): def __init__(self, status, message): self.status = status; super().__init__(message)

class APIError(Exception):
    def __init__(self, status, message):
        self.status = status
        super().__init__(message)
try:
    raise APIError(404, 'Not found')
except APIError as e:
    print(e.status, e)

Hierarquia de exceções

Crie uma hierarquia: class DBError(AppError): pass — quem chama o código pode capturar AppError para qualquer erro da aplicação ou DBError especificamente.

class AppError(Exception): pass
class DBError(AppError): pass
class NetworkError(AppError): pass
try:
    raise DBError('timeout')
except AppError as e:
    print('app error:', e)

Método str personalizado

Substitua __str__ para controlar a aparência da mensagem da exceção quando ela for impressa.

class RangeError(ValueError):
    def __init__(self, val, lo, hi):
        self.val, self.lo, self.hi = val, lo, hi
    def __str__(self):
        return f'{self.val} not in [{self.lo}, {self.hi}]'
print(RangeError(15, 0, 10))

Gerando exceções personalizadas

Use raise nas suas funções para sinalizar erros específicos do domínio. Isso cria uma API clara para quem chama o código.

class InsufficientFundsError(Exception):
    def __init__(self, needed, available):
        super().__init__(f'Need {needed}, have {available}')
def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount
try:
    withdraw(100, 200)
except InsufficientFundsError as e:
    print(e)

Capturando pela classe base

except AppError captura todas as subclasses: DBError, NetworkError e outras. A hierarquia permite escolher o nível de especificidade.

class AppError(Exception): pass
class DBError(AppError): pass
try:
    raise DBError('conn failed')
except AppError:
    print('any app error')

Exceção com gerenciador de contexto

Exceções personalizadas integram-se a gerenciadores de contexto: class suppressed: __exit__ retorna True para suprimir a exceção.

class SuppressValue(Exception): pass
try:
    raise SuppressValue('ignored')
except SuppressValue:
    pass  # suppress silently
print('continued')

Documentando exceções personalizadas

Documente WHEN gerar a exceção e WHAT os atributos significam. Boas strings de documentação tornam as exceções personalizadas fáceis de usar.

class ConfigError(Exception):
    """Raised when configuration is invalid.
    Attributes:
        key: The invalid config key
    """
    def __init__(self, key, msg):
        super().__init__(msg)
        self.key = key

Práticas recomendadas

Mantenha a hierarquia rasa (2 ou 3 níveis). Sempre herde de Exception. Use nomes descritivos terminados em Error. Coloque-as em um módulo dedicado exceptions.py.

# Good structure:
class AppError(Exception): pass
class ValidationError(AppError): pass
class NotFoundError(AppError): pass
print('hierarchy demo')

Verificação rápida

De que classe as exceções personalizadas devem herdar para evitar a captura de eventos que encerram o sistema?

Recapitulação

Exceções personalizadas: herde de Exception, adicione atributos em __init__ e substitua __str__. Crie hierarquias para facilitar a captura. Coloque-as no módulo exceptions.py.

Continue avançando

Excelente trabalho! Passe à próxima lição para continuar avançando.

Perguntas Frequentes

A aula “Classes de exceção personalizadas” é grátis?

Sim — o texto completo de “Classes de exceção personalizadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Classes de exceção personalizadas”?

Defina seus próprios tipos de exceção para comunicar erros com mais clareza. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Classes de exceção personalizadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy