Manipulação de Erros e Registros em Python

() translation by (you can also view the original English article)

Em desenvolvimento de software, vários tipos de erros acontecem. Eles podem ser de sintaxe, lógicos ou de execução.

Erros de sintaxe acontecem durante a fase inicial do desenvolvimento e são por sintaxe incorreta. Eles são pegos facilmente quando o programa é compilado para execução.

Erros lógicos, por outro lado, são resultado de implementação lógica imprópria. Um exemplo seria um programa acessar uma lista não ordenada como se tivesse ordenada. Erros lógicos são os mais difíceis de rastrear.

Erros de tempo de execução são os mais interessantes, se não considerarmos os casos extremos. Um exemplo seria tentar acessar um arquivo não existente.

Nesse tutorial, aprenderemos como lidar com erros em Python e como registrá-los para melhor entendê-los o que aconteceu de errado na aplicação.

Manipulando Exceções em Python

Comecemos com um programa simples que adiciona dois números. O programa recebe dois parâmetros de entrada e imprime a soma. Eis o programa em Python:

1	def addNumbers(a, b):
2	print a + b
3
4	addNumbers(5, 10)

Tentemos executar o programa acima e veremos soma impressa.

Ao escrever o programa cima, não consideramos o que pode acontecer de errado. E se um dos parâmetros não forem números?

1	addNumbers('', 10)

Não lidamos com esse caso, assim, nosso programa travaria com a seguinte mensagem de erro:

Traceback (most recent call last):
  File "addNumber.py", line 4, in <module>
    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 checando se os parâmetros passados são inteiros. Mas isso não resolveria o problema. E se o programa acabar travando por outro motivo? Trabalhar com um programa que trava quando encontra um erro, não é um bom sinal. Mesmo que um erro desconhecido seja encontrado, o código deve ser robusto suficiente para lidar graciosamente e permitir o usuário saber que algo errado aconteceu.

Manipulando Exceções Usando Try e Except

Em Python, usamos try e except para lidar com exceções. Sempre que o código trava, uma exceção é lançada sem travar o programa. Modifiquemos o nosso programa para incluir as declarações de try e except.

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 de try e except. Ao encontrar um erro, o controle é passado para o bloco except, pulando o código antes dele.

Como visto acima, movemos nosso código para dentro de try e except. Ao executar o programa, uma mensagem de erro será mostrada ao invés de travá-lo. O motivo da exceção também é retornado como mensagem.

O método acima lida com exceções inesperadas. Vejamos como lidar com exceções esperadas. Assumamos que tentamos ler um arquivo específico no nosso programa, mas ele não existe. Nesse caso, lidaremos com a exceção e avisaremos o usuário que o arquivo não existe. Vejamos o código:

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, lidamos com a leitura de arquivos no manipulador de erros IOError. Se o código travar pela não disponibilidade do arquivo fname, ele será lidado pelo manipulador IOError. Como as exceções IOError, existem várias outras exceções padrões, como Arithmetic, OverflowError e ImportError, para citar algumas.

Múltiplas Exceções

Podemos manipular múltiplas exceções de ums só vez, juntando exceções padrões, assim:

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

Esse código imprimiria mensagens para exceções IOError e NameError quando o programa executasse.

A Cláusula `finally`

Assumamos que usamos certos recursos em nosso programa. Durante sua execução, ele encontrou um erro e só foi executado pela metade. Nesse caso, o recurso ficaria preso desnecessariamente. Podemos limpar recursos usando a cláusula finally. Vejamos o 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 desse código, uma exceção fosse lançada durante a leitura de um arquivo, filePointer seria fechado no bloco finally.

Registrando em Python

Quando algo sair errado numa aplicação, a depuração é facilitada quando sabemos a fonte do erro. Quando uma exceção é lançada, podemos registrar a informação necessária para rastrear o problema. Python provê uma biblioteca simples e poderosa para registros. Vejamos como usá-la.

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 vemos acima, primeiro importamos a biblioteca de registros e inicializamos o registrador com o nome do registro e o nível. Há cinco níveis de registro: DEBUG, INFO, WARNING, ERROR e CRITICAL. Aqui, configuramos o nível como INFO, e ambos os erros seriam registrados.

Obtendo a Pilha de Rastreio

No código acima, tínhamos apenas um programa, por isso era fácil saber onde o erro aconteceu. Mas, o que acontece quando vários arquivos de programas estão envolvidos? Nesses casos, obter a pilha de rastreio do erro ajuda a encontrar a fonte do erro. Ela pode ser registrada, dessa forma:

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 executarmos o programa acima, ele lançaria uma exceção e o erro abaixo seria registrado no arquivo:

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

Resumindo

Nesse tutorial, vimos como começar a manipular erros em Python e a usar o módulo de registros para registrá-los. Vimos o uso de try, except e finally, que são bem úteis ao lidar com manipulação de erros. Para mais informações, recomendamos a leitura da documentação oficial sobre registros. A leitura sobre manipulação de erros em Python também é interessante.

Diga-nos o que achou nos comentários abaixo.