Manipulação de erros e registro em Python

No desenvolvimento de software, diferentes tipos de erros podem ocorrer. Eles podem ser erros de sintaxe, erros lógicos ou erros de tempo de execução.

Erros de sintaxe provavelmente ocorrem durante a fase inicial de desenvolvimento e são resultado de sintaxe incorreta. Erros de sintaxe podem ser detectados facilmente quando o programa é compilado para execução.

Os erros lógicos, por outro lado, são resultado de uma implementação lógica imprópria. Um exemplo seria um programa acessando uma lista não classificada supondo que ela esteja classificada. Erros lógicos são os mais difíceis de rastrear.

Erros de tempo de execução são os erros mais interessantes que ocorrem, se não considerarmos todos os casos de canto. Um exemplo seria tentar acessar um arquivo inexistente.

Neste tutorial, aprenderemos como lidar com erros em Python e como registrar os erros para entender melhor o que deu errado dentro do aplicativo.

Manipulando Exceções em Python

Vamos começar com um programa simples para somar dois números em Python. Nosso programa recebe dois parâmetros como entrada e imprime a soma. Aqui está um programa Python para adicionar dois números:

def addNumbers(a, b):
    print a + b

addNumbers(5, 10)

Tente executar o programa Python acima e você deverá ter a soma impressa.

15

Ao escrever o programa acima, não consideramos o fato de que tudo pode dar errado. E se um dos parâmetros passados ​​não for um número?

addNumbers('', 10)

Não tratamos desse caso, portanto, nosso programa travaria com a seguinte mensagem de erro:

Traceback (most recent call last):
  File "addNumber.py", line 4, in 
    addNumbers('', 10)
  File "addNumber.py", line 2, in addNumbers
    print a + b
TypeError: cannot concatenate 'str' and 'int' objects

Podemos lidar com o problema acima verificando se os parâmetros passados ​​são inteiros. Mas isso não vai resolver o problema. E se o código falhar devido a algum outro motivo e fizer com que o programa falhe? Trabalhar com um programa que trava ao ser encontrado com um erro não é uma boa visão. Mesmo se um erro desconhecido for encontrado, o código deve ser robusto o suficiente para lidar com o travamento de forma harmoniosa e informar ao usuário que algo está errado.

Manipulando Exceções Usando Try e Except

Em Python, usamos o try e except instruções para lidar com exceções. Sempre que o código falha, uma exceção é lançada sem travar o programa. Vamos modificar o programa add number para incluir o try e except declarações.

def addNumbers(a, b):
    try:
        return a + b
    except Exception as e:
        return 'Error occurred : ' + str(e)

print addNumbers('', 10)

Python processaria todo o código dentro do try e except declaração. Quando encontra um erro, o controle é passado para o except bloco, pulando o código no meio.

Como visto no código acima, movemos nosso código dentro de um try e except declaração. Tente executar o programa e ele deve gerar uma mensagem de erro em vez de travar o programa. O motivo da exceção também é retornado como uma mensagem de exceção.

O método acima lida com exceções inesperadas. Vamos dar uma olhada em como lidar com uma exceção esperada. Suponha que estamos tentando ler um arquivo específico usando nosso programa Python, mas o arquivo não existe. Nesse caso, trataremos a exceção e informaremos ao usuário que o arquivo não existe quando isso acontecer. Dê uma olhada no código de leitura do arquivo:

try:
    try:
        with open('fname') as f:
            content = f.readlines()
    except IOError as e:
        print str(e)
except Exception as e:
    print str(e)

No código acima, tratamos da leitura do arquivo dentro de um IOError manipulador de exceções. Se o código falhar devido à indisponibilidade do arquivo fnameo erro seria tratado dentro do IOError manipulador. Semelhante ao IOError exceções, existem muito mais exceções padrão como Arithmetic, OverflowErrore ImportErrorpara nomear alguns.

Várias exceções

Podemos lidar com várias exceções ao mesmo tempo batendo as exceções padrão, conforme mostrado:

try:
    with open('fname') as f:
        content = f.readlines()
    printb
except (IOError,NameError) as e:
    print str(e)

O código acima aumentaria tanto o IOError e NameError exceções quando o programa é executado.

finally Cláusula

Suponha que estamos usando certos recursos em nosso programa Python. Durante a execução do programa, ele encontrou um erro e só foi executado na metade. Nesse caso, o recurso seria retido desnecessariamente. Podemos limpar esses recursos usando o finally cláusula. Dê uma olhada no código abaixo:

try:
    filePointer = open('fname','r')
    try:
        content = filePointer.readline()
    finally:
        filePointer.close()
except IOError as e:
    print str(e)

Se, durante a execução do código acima, for gerada uma exceção durante a leitura do arquivo, o filePointer seria fechado no finally quadra.

Logando em Python

Quando algo dá errado dentro de um aplicativo, fica mais fácil depurar se soubermos a origem do erro. Quando uma exceção é gerada, podemos registrar as informações necessárias para rastrear o problema. Python fornece uma biblioteca de log simples e poderosa. Vamos dar uma olhada em como usar o log em Python.

import logging

# initialize the log settings
logging.basicConfig(filename="app.log",level=logging.INFO)

try:
    logging.info('Trying to open the file')
    filePointer = open('appFile','r')
    try:
        logging.info('Trying to read the file content')
        content = filePointer.readline()
    finally:
        filePointer.close()
except IOError as e:
    logging.error('Error occurred ' + str(e))

Como visto no código acima, primeiro precisamos importar a biblioteca Python de log e, em seguida, inicializar o logger com o nome do arquivo de log e o nível de log. Existem cinco níveis de log: DEBUG, INFO, WARNING, ERROR e CRITICAL. Aqui definimos o nível de log para INFO, portanto, o INFO e os logs acima seriam registrados.

Obtendo o rastreamento de pilha

No código acima, tínhamos um único arquivo de programa, portanto, foi mais fácil descobrir onde ocorreu o erro. Mas o que fazemos quando vários arquivos de programa estão envolvidos? Nesse caso, obter o rastreamento de pilha do erro ajuda a encontrar a origem do erro. O rastreamento de pilha da exceção pode ser registrado como mostrado:

import logging

# initialize the log settings
logging.basicConfig(filename="app.log", level = logging.INFO)

try:
    filePointer = open('appFile','r')
    try:
        content = filePointer.readline()
    finally:
        filePointer.close()
except IOError as e:
    logging.exception(str(e))

Se você tentar executar o programa acima, ao gerar uma exceção, o seguinte erro será registrado no arquivo de log:

ERROR:root:[Errno 2] No such file or directory: 'appFile'
Traceback (most recent call last):
  File "readFile.py", line 7, in 
    filePointer = open('appFile','r')
IOError: [Errno 2] No such file or directory: 'appFile'

Embrulhando-o

Neste tutorial, vimos como começar a lidar com erros em Python e usar o módulo de log para registrar erros. Vimos o uso de try, except e finally instruções, que são bastante úteis ao lidar com tratamento de erros em Python. Para informações mais detalhadas, recomendo a leitura da documentação oficial sobre log. Também dê uma olhada na documentação para lidar com exceções em Python.

Deixe-nos saber seus pensamentos nos comentários abaixo.