Tratamento de exceções no Python - Try, Except e Finally

Neste artigo, você aprenderá como usar as instruções try, except e finally para lidar com exceções em programas Python. Isso o incentivará a escrever código limpo, legível e eficiente em Python.

O que são exceções no Python?

O Python tem muitosExceções integradas 　Quando alguns erros ocorrem, eles forçam seu programa a emitir erros.

Quando essas exceções ocorrem, elas causarão a interrupção do processo atual e serão passadas para o processo de chamada, até que sejam tratadas. Se não forem tratadas, nosso programa falhará.

Por exemplo, se a função A chama a função B, e esta, por sua vez, chama a função C, e ocorre uma exceção na função C. Se a exceção não for tratada na C, ela será passada para B e, em seguida, para A.

Se não for tratada, uma mensagem de erro será lançada e nosso programa parará inesperadamente.

Capturar exceções no Python

No Python, é possível usar a instrução try para lidar com exceções.

As operações que podem gerar exceções são colocadas dentro de uma cláusula try, e o código de tratamento de exceções é escrito na cláusula except.

Após capturar a exceção, a ação que executaremos depende de nós mesmos. Este é um exemplo simples.

# Importar o módulo sys para obter o tipo da exceção
import sys
randomList = [‘a’, 0,　2]
for entry in randomList:
　　　　try:
　　　　　　　　print(“A entrada é”, entry)
　　　　　　　　r =　1/int(entry)
　　　　　　　　break
　　　　except:
　　　　　　　　print(“Oops!”, sys.exc_info()[0], “ocorreu.”)
　　　　　　　　print(“Próxima entrada.”)
　　　　　　　　print()
print(“O recíproco de”, entry, “é”, r)

Saída de resultados

A entrada é a
Oops! <class ‘ValueError’> ocorreu.
Próxima entrada.
A entrada é 0
Oops! <class ‘ZeroDivisionError’> ocorreu.
Próxima entrada.
A entrada é　2
O recíproco de　2　é 0.5

Neste programa, executamos em loop até que o usuário insira um inteiro com um inverso válido. A parte que pode causar exceção é colocada dentro do bloco try.

Se não ocorrer nenhuma exceção, o conteúdo fora do bloco except será pulado e o fluxo normal continuará. Mas se ocorrer qualquer exceção, ela será capturada pelo bloco except.

Aqui, usamos a função exinfo() do módulo sys para imprimir o nome da exceção e pedimos ao usuário para tentar novamente. Podemos ver os valores ‘a’ e ‘1.3’causará ValueError, ‘0’ causará ZeroDivisionError.

Capturar exceções específicas do Python

No exemplo acima, não mencionamos nenhuma exceção na subclausula except.

Não é um bom hábito de programação, pois ela captura todas as exceções e trata cada caso da mesma forma. Podemos especificar quais exceções a subclausula except capturará.

Uma cláusula try pode ter qualquer número de subclausulas except para tratá-las de diferentes maneiras, mas apenas uma subclausula except será executada quando uma exceção ocorrer.

Podemos usar tuplas de valores para especificar múltiplas exceções em subclausulas except. Abaixo está um exemplo de pseudocódigo.

try:
　　　# Executar algum código
　　　pass
except ValueError:
　　　# Tratar exceção ValueError
　　　pass
except (TypeError, ZeroDivisionError):
　　　# Tratar múltiplas exceções
　　　# TypeError e ZeroDivisionError exceções
　　　pass
except:
　　　# Tratar todas as outras exceções
　　　pass

Lançar exceção

Em programação Python, exceções são lançadas quando ocorrem erros correspondentes durante a execução, mas podemos usar a palavra-chave raise para forçar o lançamento de exceções.

Também podemos optar por passar valores para as exceções para esclarecer por que a exceção foi lançada.

>>> raise KeyboardInterrupt
Traceback (última chamada mais recente):
...
KeyboardInterrupt
>>> raise MemoryError("Este é um argumento")
Traceback (última chamada mais recente):
...
MemoryError: Este é um argumento
>>> try:
... a = int(input("Insira um número inteiro positivo: "))
... if a <= 0:
... raise ValueError("Não é um número positivo!")
... except ValueError as ve:
... print(ve)
...　　　　
Insira um número inteiro positivo:　-2
Não é um número positivo!

try...finally

A cláusula try no Python pode ter uma cláusula finally opcional. Independentemente do que aconteça, essa cláusula será executada e geralmente é usada para liberar recursos externos.

Por exemplo, podemos nos conectar a um data center remoto via conexão de rede, ou usar arquivos ou GUI (Graphical User Interface).

Em todos esses casos, independentemente do sucesso da recuperação do recurso, devemos limpar o recurso. Essas operações (fechar arquivos, GUI ou desconectar da rede) são executadas na cláusula finally, para garantir a execução.

Este é umOperações de arquivopara ilustrar isso.

try:
　　　f = open("test.txt", encoding = 'utf-8)
　　　# Executar operações de arquivo
finally:
　　　f.close()

Este tipo de construção garante que o arquivo seja fechado, mesmo em caso de exceção.