Como desenvolvedores Python, todos nós já passamos por isso – nosso script trava com um traceback feio e nos esforçamos para consertar isso. Mas as exceções não precisam estragar o nosso dia! Com um pouco de sutileza, podemos usá-los para lidar com erros de maneira elegante e tornar nosso código mais robusto.
Neste post, quero compartilhar algumas dicas e truques que aprendi sobre como criar e capturar exceções da maneira Pythonica. Exploraremos como as exceções funcionam nos bastidores, diferentes estratégias para lidar com elas e alguns padrões interessantes que você pode aplicar. Fique comigo e, no final, você será um profissional que luta contra exceções!
Uma breve atualização sobre exceções em Python
Antes de começarmos, vamos recapitular quais exceções realmente existem no Python. Basicamente, as exceções são objetos que fornecem informações sobre erros ou condições anômalas do programa. Quando algo anormal ocorre como um TypeError (exemplo: TypeError: os índices de string devem ser inteiros) ou ValueError (exemplo: ValueError: não foi possível converter string em float), o Python gera um objeto de exceção e transfere o controle para o manipulador de exceção.
As palavras-chave try e except nos permitem definir blocos de código a serem executados, juntamente com os manipuladores de exceção correspondentes. Isso nos permite recuperar normalmente de erros sem travar. Nos bastidores, o Python usa blocos try/except, objetos de geração e de exceção para interromper o fluxo normal do programa e passar o controle para o manipulador quando as coisas dão errado.
Não entre em pânico – levantando exceções intencionalmente em Python
Agora que entendemos as exceções em um nível básico, vamos falar sobre como criá-las nós mesmos. Você pode pensar que gerar exceções é algo que você só faz se seu código falhar, mas na verdade é uma boa prática fazer isso intencionalmente! Levantamos exceções para sinalizar que ocorreu uma condição especial em nosso código que precisa ser tratada.
Por exemplo, digamos que temos uma função que valida a entrada do usuário. Em vez de retornar Verdadeiro/Falso, podemos querer gerar tipos de exceção específicos para fornecer mais contexto sobre o que deu errado:
def validar_input(user_input):
se não for user_input:
raise ValueError(“A entrada está vazia!”)
se len(user_input) > 100:
raise InputTooLongException(“A entrada excede o comprimento máximo”)
# validação passada
retornar verdadeiro
Agora nosso código de chamada pode capturar essas exceções personalizadas para lidar com falhas de validação normalmente:
tentar:
validar_input(user_input)
exceto ValueError como e:
print(“Erro de validação:”, e)
exceto InputTooLongException como e:
print(“Erro de validação:”, e)
Criar exceções nós mesmos permite que nosso código seja mais autodocumentado e simplifica o tratamento de erros. É uma boa prática sempre que ocorrerem condições inesperadas que precisem ser resolvidas pelo código de chamada.
Capturando exceções seletivamente em Python
Agora que estamos levantando exceções intencionalmente, vamos falar sobre como capturá-las seletivamente. Por padrão, um único bloco except captura todas as exceções. Mas muitas vezes queremos um controle mais refinado.
Por exemplo, podemos escrever código que pode gerar vários tipos de erros:
tentar:
abrir arquivo()
fazer_cálculo()
enviar pedido()
exceto Exceção:
identificador_erro()
Isso captura tudo, mas todos os erros acabam no mesmo manipulador. Uma abordagem melhor é capturar exceções específicas separadamente:
tentar:
abrir arquivo()
exceto FileNotFoundError:
handle_file_error()
tentar:
fazer_cálculo()
exceto ZeroDivisionError:
handle_zero_division()
tentar:
enviar pedido()
exceto ConnectionError:
handle_connection_error()
Agora temos manipuladores direcionados para cada tipo de erro. Isso torna nosso tratamento de exceções mais robusto e evita blocos genéricos genéricos.
Também podemos capturar múltiplas exceções do mesmo bloco:
tentar:
# código que pode gerar vários tipos de exceção
exceto (IndexError, KeyError) como e:
handle_index_or_key_error(e)
O tratamento seletivo de exceções é uma técnica importante para escrever código limpo e compreensível. Tome cuidado para capturar exceções específicas, evite blocos exceto amplos e trate erros no nível certo de granularidade.
Encadeamento de exceções e contexto em Python
Até agora, capturamos objetos de exceção simples. Mas muitas vezes precisamos de mais contexto ao lidar com erros. É aí que o encadeamento de exceções é útil.
O atributo causa em objetos de exceção permite que exceções subsequentes “reivindicam” exceções anteriores como a causa. Quando uma exceção é gerada dentro de um bloco except, ela é encadeada automaticamente para a exceção capturada.
Por exemplo:
tentar:
abrir arquivo()
exceto FileNotFoundError como file_error:
tentar:
arquivo_processo()
exceto KeyError:
raise KeyError(“Chave não encontrada”) de file_error
Agora o KeyError gerado dentro do bloco except está encadeado ao FileNotFoundError original. Quando impresso ou registrado, mostrará ambas as exceções para contexto completo.
Também podemos encadear exceções explicitamente, passando a exceção anterior para raise:
tentar:
# código que pode gerar múltiplas exceções
exceto exceção como first_error:
tentar:
# código que falha
exceto exceção como segundo_erro:
raisesecond_error de first_error
O encadeamento fornece uma pilha de chamadas de exceções para ajudar a rastrear exatamente o que deu errado. É uma técnica essencial para depurar casos de falha aninhados.
Lidando com exceções com elegância em Python
Tudo bem, agora sabemos como aumentar, capturar e obter contexto em exceções programaticamente. Mas o que deveríamos realmente fazer em nossos manipuladores de exceções? Muitas vezes vejo código que apenas imprime uma mensagem de erro e gera uma exceção genérica.
Existem maneiras melhores de lidar com falhas normalmente:
- Retorne uma resposta de erro significativa em vez de travar
- Reverter quaisquer alterações parciais feitas antes da falha
- Registre informações detalhadas de exceção para ajudar na depuração posterior
- Desligar recursos de forma limpa em vez de vazar conexões
- Tente abordagens alternativas, se possível, antes de desistir
Por exemplo, em um aplicativo da web, podemos querer:
tentar:
# operação de banco de dados
exceto DatabaseError:
# transação de reversão
db.rollback()
# retorna erro HTTP 500
retornar resposta (status = 500)
Ou para um script de linha de comando:
tentar:
#abre e processa arquivo
exceto Exceção como e:
# limpar
arquivo.fechar()
# imprime erro e sai de forma limpa
imprimir(f”Erro: {e}”)
sys.exit(1)
O fracasso gracioso é subestimado! Aproveite os recursos de tratamento de exceções para tornar seus programas robustos em vez de frágeis.
Embrulhar
Esperamos que isso tenha lhe dado algumas ideias e padrões novos para trabalhar profissionalmente com exceções em Python. As principais coisas a lembrar são:
- Levantar exceções intencionalmente para sinalizar condições que necessitam de tratamento especial
- Capture tipos de exceção específicos seletivamente em vez de objetos de exceção genéricos
- Adicione contexto encadeando exceções e registrando detalhes de falhas
- Lide com exceções normalmente falhando silenciosamente em vez de travar
Dominar as exceções levará suas habilidades em Python para o próximo nível. Você pode conferir mais tutoriais sobre Python usando esse link. Tenha essas técnicas em mente e seu código ficará mais feliz, saudável e robusto quando ocorrerem situações inesperadas. Sinta-se à vontade para experimentar – as exceções são seus amigos, não inimigos!
Sobre o autor
Vinish Kapoor é um engenheiro de software experiente com mais de 20 anos de experiência na área. Sua experiência abrange vários aspectos de desenvolvimento de software, arquitetura de sistemas e gerenciamento de projetos. Entusiasta da IA, Vinish passou uma parte significativa de sua carreira explorando o potencial transformador da inteligência artificial. Seu profundo conhecimento da engenharia de software e dos princípios de IA o posiciona de forma única na indústria de tecnologia, permitindo-lhe fornecer insights valiosos e contribuir significativamente para a evolução das tecnologias de IA.
source – www.analyticsinsight.net
