Python 3 - tratamento de exceções

Python fornece dois recursos muito importantes para lidar com qualquer erro inesperado em seus programas Python e para adicionar recursos de depuração a eles -

• Exception Handling- Isso seria abordado neste tutorial. Aqui está uma lista de exceções padrão disponíveis em Python - exceções padrão .

• Assertions- Isso seria abordado no tutorial Assertions in Python 3 .

Exceções padrão

Aqui está uma lista de exceções padrão disponíveis em Python. -

Sr. Não.	Nome e descrição da exceção
1	Exception Classe base para todas as exceções
2	StopIteration Gerado quando o método next () de um iterador não aponta para nenhum objeto.
3	SystemExit Gerado pela função sys.exit ().
4	StandardError Classe base para todas as exceções integradas, exceto StopIteration e SystemExit.
5	ArithmeticError Classe base para todos os erros que ocorrem no cálculo numérico.
6	OverflowError Gerado quando um cálculo excede o limite máximo para um tipo numérico.
7	FloatingPointError Gerado quando um cálculo de ponto flutuante falha.
8	ZeroDivisonError Gerado quando a divisão ou módulo por zero ocorre para todos os tipos numéricos.
9	AssertionError Gerado em caso de falha da declaração Assert.
10	AttributeError Gerado em caso de falha de referência ou atribuição de atributo.
11	EOFError Gerado quando não há entrada da função raw_input () ou input () e o final do arquivo é alcançado.
12	ImportError Gerado quando uma instrução de importação falha.
13	KeyboardInterrupt Gerado quando o usuário interrompe a execução do programa, geralmente pressionando Ctrl + c.
14	LookupError Classe base para todos os erros de pesquisa.
15	IndexError Gerado quando um índice não é encontrado em uma sequência.
16	KeyError Gerado quando a chave especificada não é encontrada no dicionário.
17	NameError Gerado quando um identificador não é encontrado no namespace local ou global.
18	UnboundLocalError Gerado ao tentar acessar uma variável local em uma função ou método, mas nenhum valor foi atribuído a ela.
19	EnvironmentError Classe base para todas as exceções que ocorrem fora do ambiente Python.
20	IOError Gerado quando uma operação de entrada / saída falha, como a instrução de impressão ou a função open () ao tentar abrir um arquivo que não existe.
21	OSError Gerado para erros relacionados ao sistema operacional.
22	SyntaxError Gerado quando há um erro na sintaxe do Python.
23	IndentationError Gerado quando o recuo não é especificado corretamente.
24	SystemError Gerado quando o interpretador encontra um problema interno, mas quando esse erro é encontrado, o interpretador Python não fecha.
25	SystemExit Gerado quando o interpretador Python é encerrado usando a função sys.exit (). Se não for tratado no código, faz com que o interpretador saia.
26	TypeError Gerado quando uma operação ou função é tentada e inválida para o tipo de dados especificado.
27	ValueError Gerado quando a função interna para um tipo de dados tem o tipo válido de argumentos, mas os argumentos têm valores inválidos especificados.
28	RuntimeError Gerado quando um erro gerado não se enquadra em nenhuma categoria.
29	NotImplementedError Gerado quando um método abstrato que precisa ser implementado em uma classe herdada não é realmente implementado.

Asserções em Python

Uma asserção é uma verificação de integridade que você pode ativar ou desativar quando terminar de testar o programa.

• A maneira mais fácil de pensar em uma afirmação é compará-la a um raise-ifdeclaração (ou para ser mais preciso, uma declaração de aumento se não). Uma expressão é testada e, se o resultado for falso, uma exceção é levantada.

• As asserções são realizadas pela instrução assert, a palavra-chave mais recente do Python, introduzida na versão 1.5.

• Os programadores costumam colocar asserções no início de uma função para verificar se há uma entrada válida e após uma chamada de função para verificar se há uma saída válida.

A declaração de afirmação

Quando encontra uma declaração assert, o Python avalia a expressão que a acompanha, o que é verdade. Se a expressão for falsa, o Python gerará uma exceção AssertionError .

A sintaxe para assert é -

assert Expression[, Arguments]

Se a asserção falhar, o Python usará ArgumentExpression como argumento para AssertionError. As exceções AssertionError podem ser capturadas e tratadas como qualquer outra exceção, usando a instrução try-except. Se eles não forem tratados, eles encerrarão o programa e produzirão um rastreamento.

Exemplo

Aqui está uma função que converte uma determinada temperatura de graus Kelvin para graus Fahrenheit. Como 0 ° K é o mais frio possível, a função desiste se vê uma temperatura negativa -

#!/usr/bin/python3

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

Quando o código acima é executado, ele produz o seguinte resultado -

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

O que é exceção?

Uma exceção é um evento que ocorre durante a execução de um programa que interrompe o fluxo normal das instruções do programa. Em geral, quando um script Python encontra uma situação com a qual não pode lidar, ele levanta uma exceção. Uma exceção é um objeto Python que representa um erro.

Quando um script Python levanta uma exceção, ele deve tratar a exceção imediatamente, caso contrário ele termina e sai.

Lidando com uma exceção

Se você tiver algum código suspeito que possa gerar uma exceção, você pode defender seu programa colocando o código suspeito em umtry:quadra. Após o bloco try:, inclua umexcept: declaração, seguida por um bloco de código que trata o problema da forma mais elegante possível.

Sintaxe

Aqui está a sintaxe simples de try .... except ... else blocks -

try:
   You do your operations here
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Aqui estão alguns pontos importantes sobre a sintaxe mencionada acima -

• Uma única instrução try pode ter várias instruções except. Isso é útil quando o bloco try contém instruções que podem lançar diferentes tipos de exceções.

• Você também pode fornecer uma cláusula exceto genérica, que trata de qualquer exceção.

• Após a (s) cláusula (s) except, você pode incluir uma cláusula else. O código no bloco else é executado se o código no bloco try: não gerar uma exceção.

• O bloco else é um bom lugar para código que não precisa da proteção do bloco try:.

Exemplo

Este exemplo abre um arquivo, grava conteúdo no arquivo e sai normalmente porque não há nenhum problema -

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")
   fh.close()

Isso produz o seguinte resultado -

Written content in the file successfully

Exemplo

Este exemplo tenta abrir um arquivo onde você não tem permissão de gravação, então ele levanta uma exceção -

#!/usr/bin/python3

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")

Isso produz o seguinte resultado -

Error: can't find file or read data

A cláusula except sem exceções

Você também pode usar a instrução except sem exceções definidas como segue -

try:
   You do your operations here
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Este tipo de try-exceptdeclaração captura todas as exceções que ocorrem. Usar este tipo de instrução try-except não é considerado uma boa prática de programação, porque captura todas as exceções, mas não faz o programador identificar a causa raiz do problema que pode ocorrer.

A cláusula except com múltiplas exceções

Você também pode usar a mesma instrução except para lidar com várias exceções da seguinte forma -

try:
   You do your operations here
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

A cláusula try-finally

Você pode usar um finally: bloquear junto com um try:quadra. ofinally:bloco é um local para colocar qualquer código que deva ser executado, quer o bloco try tenha gerado uma exceção ou não. A sintaxe da instrução try-finally é esta -

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Note- Você pode fornecer exceto cláusula (s) ou uma cláusula final, mas não ambas. Você não pode usar a cláusula else também junto com uma cláusula finally.

Exemplo

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print ("Error: can\'t find file or read data")
   fh.close()

Se você não tiver permissão para abrir o arquivo no modo de gravação, isso produzirá o seguinte resultado -

Error: can't find file or read data

O mesmo exemplo pode ser escrito de forma mais limpa da seguinte maneira -

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print ("Going to close the file")
      fh.close()
except IOError:
   print ("Error: can\'t find file or read data")

Isso produz o seguinte resultado -

Going to close the file

Quando uma exceção é lançada no bloco try , a execução passa imediatamente para o bloco finally . Depois que todas as instruções no bloco finally são executadas, a exceção é gerada novamente e tratada nas instruções except se presente na próxima camada superior da instrução try-except .

Argumento de uma exceção

Uma exceção pode ter um argumento , que é um valor que fornece informações adicionais sobre o problema. O conteúdo do argumento varia por exceção. Você captura o argumento de uma exceção fornecendo uma variável na cláusula except da seguinte forma -

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

Se você escrever o código para tratar uma única exceção, poderá ter uma variável após o nome da exceção na instrução except. Se você estiver capturando várias exceções, poderá fazer com que uma variável siga a tupla da exceção.

Esta variável recebe o valor da exceção contendo principalmente a causa da exceção. A variável pode receber um único valor ou vários valores na forma de uma tupla. Essa tupla geralmente contém a string de erro, o número do erro e uma localização do erro.

Exemplo

A seguir está um exemplo para uma única exceção -

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

Isso produz o seguinte resultado -

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Levantando uma exceção

Você pode levantar exceções de várias maneiras usando a instrução raise. A sintaxe geral para oraise declaração é a seguinte -

Sintaxe

raise [Exception [, args [, traceback]]]

Aqui, Exception é o tipo de exceção (por exemplo, NameError) e argument é um valor para o argumento de exceção. O argumento é opcional; se não for fornecido, o argumento de exceção é Nenhum.

O argumento final, traceback, também é opcional (e raramente usado na prática) e, se presente, é o objeto traceback usado para a exceção.

Exemplo

Uma exceção pode ser uma string, uma classe ou um objeto. A maioria das exceções levantadas pelo núcleo do Python são classes, com um argumento que é uma instância da classe. Definir novas exceções é muito fácil e pode ser feito da seguinte forma -

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

Note- Para capturar uma exceção, uma cláusula "except" deve referir-se à mesma exceção lançada como um objeto de classe ou uma string simples. Por exemplo, para capturar a exceção acima, devemos escrever a cláusula except da seguinte forma -

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

O exemplo a seguir ilustra o uso de gerar uma exceção -

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

Isso produzirá o seguinte resultado

error in level argument -10

Exceções definidas pelo usuário

Python também permite que você crie suas próprias exceções derivando classes das exceções padrão embutidas.

Aqui está um exemplo relacionado a RuntimeError . Aqui, é criada uma classe que é uma subclasse de RuntimeError . Isso é útil quando você precisa exibir informações mais específicas quando uma exceção é detectada.

No bloco try, a exceção definida pelo usuário é gerada e capturada no bloco except. A variável e é usada para criar uma instância da classe Networkerror .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Assim, depois de definir a classe acima, você pode gerar a exceção da seguinte maneira -

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args