Python Try Except é uma construção usada em Python para lidar com exceções normalmente, sem travar.
O tratamento de exceções torna o código do seu programa mais confiável e menos propenso a falhar. Este artigo orienta o tratamento de exceções e os cenários comuns em que o tratamento de exceções é ideal. Como bônus, também abordaremos como gerar exceções.
últimas postagens
O que é tratamento de exceções?
As exceções são anomalias e erros críticos que surgem durante a execução de um programa. Se não forem tratadas, as exceções travarão o programa. Portanto, o tratamento de exceções é uma forma de lidar com exceções para garantir que elas não travem o programa.
Aqui está um exemplo para ilustrar o que é uma exceção.
user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)
À primeira vista, parece que não há nada de errado com o programa acima. Ele recebe a entrada do usuário e a converte em um número inteiro. A seguir, exibe o número inteiro fornecido pelo usuário duplicado.
O programa funciona bem se você executá-lo com um valor de entrada 5. Veja abaixo.
Mas suponha que você executou o mesmo programa novamente. Só que desta vez, em vez de usar 5 como entrada, você insere a string “hello”. O programa irá falhar. A string “hello” não pode ser convertida em um número inteiro, então uma exceção é gerada e o programa trava.
Por que as exceções são levantadas e por que você deve tratá-las?
Exceções são levantadas porque frequentemente decompomos programas em funções ao codificá-los. Essas funções são então chamadas para executar diferentes tarefas.
No exemplo acima, chamamos a função input para receber a entrada do usuário, depois chamamos a função int para converter a string de entrada em um número inteiro e, por último, chamamos a função print para exibir alguma saída.
Entretanto, à medida que as funções executam suas ações, elas podem encontrar erros que não sabem como tratar. Neste caso, as referidas funções devem parar de funcionar e comunicar que foi encontrado um erro. Para se comunicar, eles levantarão exceções.
O código chamado de função é responsável por ouvir essas exceções e reagir adequadamente. Se isso não for feito, o programa irá travar após encontrar erros, como vimos no exemplo anterior.
Portanto, as exceções são essencialmente um mecanismo de comunicação que permite que uma função que foi chamada envie um sinal de socorro ao código que a chamou. E a reação mencionada anteriormente é a essência do tratamento de exceções.
Diferentes tipos de exceções
É importante saber que nem todas as exceções são iguais. Existem diferentes tipos de exceções levantadas para diferentes erros encontrados. Por exemplo, se você tentar dividir um número por zero, um ZeroDivisionError será gerado. E um TypeError é gerado quando você tenta uma operação com um tipo de dados inválido. Aqui está uma lista completa de tipos de exceções.
Como lidar com exceções
Conforme explicado anteriormente, as exceções são sinais de socorro feitos por funções que chamamos. Nosso código deve, portanto, ouvir esses sinais de socorro e reagir adequadamente quando eles soarem. Para lidar com exceções de maneira adequada, usamos construções Python Try Except. A estrutura básica da construção é a seguinte:
try:
# Code to try and run
except:
# Code to run if an exception is raised
finally:
# Code to run in the end, whether or not an exception is raised
Como você pode ver, a construção é composta por três palavras-chave explicadas a seguir:
tentar
A palavra-chave try marca o início de uma construção Try Except do Python. Além disso, marca um bloco de código que poderia gerar uma exceção. É uma instrução para o interpretador Python tentar executar o código no bloco. Se uma exceção for levantada, o programa para imediatamente e salta para executar o código escrito dentro do bloco except.
exceto
A palavra-chave except marca o bloco de código que será executado se uma exceção for levantada durante a execução do bloco try. Você pode definir vários blocos except para diferentes tipos de exceções que podem ser levantadas. Isto será ilustrado mais tarde.
finalmente
A palavra-chave finalmente é a terceira e última palavra-chave usada em Python Try Except. Ele marca um bloco de código que será executado independentemente de uma exceção ser gerada ou não.
Um exemplo
Aqui está um exemplo de como as palavras-chave acima podem lidar com uma exceção. Modificaremos o exemplo anterior para isso.
try:
user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)
except:
print("Something went wrong")
finally:
print("This code will be executed no matter what")
Se você executar o código acima com 5, uma entrada válida, como entrada, você obterá o seguinte:
E se você executá-lo com “hello” como entrada, obterá o seguinte:
Portanto, quando nenhuma exceção foi levantada durante a execução do código no bloco try, o computador passou para o bloco final. No entanto, quando uma exceção foi gerada durante a execução do código no bloco try, o computador passou para o bloco exceto e, em seguida, para o bloco final.
Você também pode lidar com exceções para tipos específicos de erros. Por exemplo, se quiser lidar com as exceções ValueError e KeyboardInterrupt de uma maneira específica, você pode modificar o código acima da seguinte forma:
try:
user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)
except ValueError:
print("Value can't be converted to int")
except KeyboardInterrupt:
print("Received a keyboard interrupt")
except:
print("Catch-all exception block")
finally:
print("This code will be executed no matter what")
No código acima, temos 3 blocos exceto. O primeiro bloco except captura apenas exceções ValueError, enquanto o segundo captura apenas exceções KeyboardInterrupt. O último bloco except não possui um tipo de exceção associado para escutar. Como resultado, ele captura o restante das exceções não capturadas pelos dois primeiros blocos.
Executando o código acima, você deverá obter uma saída semelhante a esta:
Quando uma exceção é gerada, você pode obter mais informações sobre a exceção no objeto de exceção. Para obter acesso ao objeto de exceção, você usa a palavra-chave as. É usado da seguinte forma:
try:
user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)
except ValueError as e:
print("Value Error:", e)
except KeyboardInterrupt as e:
print("Keyboard Interrupt:", e)
except Exception as e:
print("Some other exception", e)
Como levantar exceções
Até agora, temos lidado com exceções levantadas por outras funções. No entanto, também é possível gerar exceções em seu código. Para gerar uma exceção, usamos a palavra-chave raise. Também especificamos uma classe que representa o tipo de exceção que queremos gerar e a mensagem legível associada à exceção.
Usamos a classe Exception no exemplo a seguir para gerar uma exceção genérica. A seguir, passamos a mensagem para o construtor da classe.
raise Exception('Something went wrong')
Se você executar o trecho acima como um programa, obterá um resultado semelhante a este:
Você também pode especificar diferentes tipos de exceções. Por exemplo, você pode gerar uma exceção TypeError quando um valor tiver o tipo de dados errado:
def double(x):
if isinstance(x, int):
return x * 2
else
raise TypeError('x should be an int')
Ou se o valor especificado estiver fora dos limites aceitáveis, você poderá gerar um ValueError:
def say_hello(name):
if name == '':
raise ValueError('Value outside bounds')
else:
print('Hello', name)
Você também pode criar seus tipos de exceção criando uma subclasse da classe Exception. Aqui está um exemplo:
class InvalidHTTPMethod(Exception):
pass
No exemplo acima, criamos uma classe InvalidHTTPMethod, que herda da classe Exception. Podemos usá-lo da mesma forma que antes para gerar exceções:
raise InvalidHTTPMethod('Must be GET or POST')
Casos de uso comuns para tratamento de exceções
O tratamento de exceções é usado em muitos cenários. O exemplo anterior mostrou como ele pode lidar com exceções devido à entrada do usuário. Esta seção cobrirá duas situações adicionais em que o tratamento de exceções é útil. Eles tratam de exceções como resultado de solicitações de rede com falha e de exceções durante a leitura de arquivos.
Fazendo solicitações de rede
No exemplo abaixo, estamos fazendo uma solicitação ao Google. Estamos atentos às exceções para lidar com elas. Essas exceções são definidas no objeto requests.exceptions.
import requests
try:
response = requests.get("https://google.com")
# Check if the response status code is in the 200-299 range (successful response)
if 200 <= response.status_code < 300:
print("Request was successful!")
else:
print(f"Request failed with status code: {response.status_code}")
except requests.exceptions.RequestException as e:
print(f"RequestException occurred: {e}")
except requests.exceptions.ConnectionError as e:
print(f"ConnectionError occurred: {e}")
except requests.exceptions.Timeout as e:
print(f"Timeout occurred: {e}")
except requests.exceptions.TooManyRedirects as e:
print(f"TooManyRedirects occurred: {e}")
except requests.exceptions.HTTPError as e:
print(f"HTTPError occurred: {e}")
except Exception as e:
print(f"An unexpected error occurred: {e}")
Lendo dados de um arquivo
Neste último exemplo, estamos lendo dados do arquivo hello.txt. Também estamos lidando com exceções comuns que podem ser levantadas, como o erro FileNotFound e IOError.
try:
with open(file_path, 'r') as file:
data = file.read()
print("File contents:")
print(data)
except FileNotFoundError as e:
print(f"FileNotFoundError occurred: {e}")
except IOError as e:
print(f"IOError occurred: {e}")
except Exception as e:
print(f"An unexpected error occurred: {e}")
Conclusão
Este artigo explorou o que eram exceções e por que foram levantadas. Também estabelecemos que os tratamos para tornar o código mais confiável e evitar travamentos. Por último, abordamos como lidar com exceções e também como gerar algumas exceções.
A seguir, confira os tipos de erros comuns do Python e como resolvê-los.