Manejo de Errores y Registros en Python

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

En desarrollo de software, diferentes tipos de errores pueden ocurrir. Podrían ser errores de sintaxis, errores lógicos o errores de tiempo de ejecución.

Los errores de sintaxis es más probable que ocurran durante la fase de desarrollo inicial y son el resultado de sintaxis incorrecta. Los errores de sintaxis pueden ser atrapados fácilmente cuando se compila el programa para su ejecución.

Los errores lógicos, por otra parte, son el resultado de una incorrecta implementación lógica. Un ejemplo sería un programa accediendo a una lista no ordenada suponiendo que lo estuviera. Los errores lógicos son los más difíciles de rastrear.

Los errores de tiempo de ejecución son los errores que ocurren más interesantes, si no consideramos todos los casos posibles. Un ejemplo sería tratar de acceder a un archivo inexistente.

En este tutorial, aprenderemos cómo manejar errores en Python y cómo registrar los errores para una mejor comprensión de lo que pasó dentro de la aplicación.

Manejando Excepciones en Python

Vamos a empezar con un sencillo programa para sumar dos números en Python. Nuestro programa toma dos parámetros como entrada e imprime la suma. Aquí está un programa en Python para sumar dos números:

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

Intenta ejecutar el programa anterior de Python, y deberías de obtener la suma impresa.

Al escribir el programa anterior, realmente no consideramos el hecho de que algo pudiera salir mal. ¿Qué pasaría si uno de los parámetros pasados no es un número?

1	addNumbers('', 10)

No hemos manejado ese caso, por lo tanto, nuestro programa se va a romper con el siguiente mensaje de error:

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 manejar la cuestión anterior comprobando si los parámetros pasados son números enteros. Pero eso no soluciona el problema. ¿Qué pasa si el código se rompe por alguna otra razón y causa que el programa se bloquee? Trabajar con un programa que se rompe al encontrarse con un error no es da una buena vista. Incluso si se ha producido un error desconocido, el código debe ser lo suficientemente robusto como para manejar la ruptura con gracia y que el usuario sepa que algo está mal.

Manejo de Excepciones Usando Try y Except

En Python, utilizamos las declaraciones try y except para controlar excepciones. Cuando el código se rompe, se produce una excepción sin que se caiga el programa. Vamos a modificar el programa que agrega números para incluir las declaraciones try y except.

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

print addNumbers('', 10)

Python procesaría todo el código dentro de las declaraciones try y except. Cuando encuentra un error, el control se pasa al bloque except, omitiendo el código en el medio.

Como se ve en el código anterior, nos hemos trasladado nuestro código dentro de una declaración try y except. Intenta ejecutar el programa y debe lanzar un mensaje de error en lugar de que se caiga el programa. También, el motivo de la excepción se devuelve como un mensaje de excepción.

El método anterior maneja las excepciones inesperadas. Echemos un vistazo a cómo manejar una excepción prevista. Asume que estamos tratando de leer un archivo con nuestro programa de Python, pero el archivo no existe. En este caso, controlaremos la excepción y permitiremos al usuario saber que el archivo no existe cuando ocurra. Echa un vistazo al código de lectura de archivo:

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

En el código anterior, hemos manejado la lectura de archivo dentro de un controlador de excepción IOError. Si el código se rompe debido a la falta de disponibilidad del archivo fname, el error sería manejado dentro del controlador IOError. Similar a la excepción IOError, hay excepciones mucho más estándar como Arithmetic, OverflowError e ImportError, por nombrar unos pocos.

Múltiples Excepciones

Podemos manejar excepciones múltiples a la vez juntando las excepciones estándar como se muestra:

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

El código anterior mostraría las excepciones IOError y NameError cuando se ejecute el programa.

Clausula `finally`

Supongamos que estamos utilizando ciertos recursos en nuestro programa de Python. Durante la ejecución del programa, se encontró un error y sólo se ejecutó a medias. En este caso, el recurso será mantenido innecesariamente. Podemos limpiar tales recursos mediante la cláusula finally. Echa un vistazo al siguiente código:

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

Si durante la ejecución del código anterior, se produce una excepción al leer el archivo, filePointer sería cerrado en el bloque finally.

Registros en Python

Cuando algo va mal dentro de una aplicación, es más fácil depurar si conocemos la fuente del error. Cuando se produce una excepción, podemos registrar la información necesaria para localizar el problema. Python proporciona una biblioteca de registro simple y potente. Vamos a echar un vistazo a cómo utilizar registros en 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 se ve en el código anterior, primero tenemos que importar la biblioteca de registro de Python y luego inicializar el registrador con el nombre del archivo de registro y nivel de registro. Hay cinco niveles de registro: DEBUG, INFO, WARNING, ERROR y CRITICAL. Aquí tenemos que ajustar el nivel de registro a INFO, por lo tanto, INFO y los registros anteriores se registrarán.

Consiguiendo el Seguimiento de Pila

En el código anterior tuvimos un archivo de programa, por lo tanto era más fácil de averiguar dónde había ocurrido el error. Pero ¿qué hacemos cuando se trata de varios archivos de programa? En tal caso, conseguir la pila de errores ayuda en la búsqueda de la fuente del error. El seguimiento de pila de la excepción puede haberse registrado como se muestra:

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))

Si intentas ejecutar el programa anterior, al surgir una excepción el siguiente error se registra en el archivo de registro:

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'

En Resumen

En este tutorial, vimos cómo empezar con el manejo de errores de Python y la utilización del módulo de registro para registrar errores. Vimos el uso de las declaraciones try, except y finally, que son muy útiles cuando se manejan errores en Python. Para obtener más información, recomiendo leer la documentación oficial sobre registros. También echa un vistazo a la documentación para manejar excepciones en Python.

Haznos saber tus ideas en los comentarios abajo.