Manejo de Excepciones en Python: Guía Completa y Práctica

Python ofrece dos características importantes para manejar errores inesperados y añadir capacidades de depuración:

• Manejo de Excepciones: Cubierto en este tutorial.

• Aserciones (Assertions): Cubiertas en tutorial separado.

Lista de Excepciones Estándar

Excepción	Descripción
Exception	Clase base para todas las excepciones
StopIteration	Se lanza cuando next() de un iterador no apunta a ningún objeto
SystemExit	Se lanza por sys.exit()
StandardError	Clase base para excepciones integradas excepto StopIteration y SystemExit
ArithmeticError	Clase base para errores de cálculo numérico
OverflowError	Cálculo excede límite máximo para un tipo numérico
FloatingPointError	Fallo en cálculo de punto flotante
ZeroDivisionError	División o módulo por cero
AssertionError	Fallo en sentencia assert
AttributeError	Fallo en referencia o asignación de atributo
EOFError	Sin entrada de raw_input()/input() y fin de archivo alcanzado
ImportError	Fallo en sentencia import
KeyboardInterrupt	Usuario interrumpe ejecución (Ctrl+C)
LookupError	Clase base para errores de búsqueda
IndexError	Índice no encontrado en secuencia
KeyError	Clave no encontrada en diccionario
NameError	Identificador no encontrado en espacio de nombres local/global
UnboundLocalError	Acceso a variable local sin valor asignado
EnvironmentError	Clase base para excepciones fuera del entorno Python
IOError	Fallo en operación I/O (print, open archivo inexistente)
OSError	Errores relacionados con el sistema operativo
SyntaxError	Error en sintaxis Python
IndentationError	Indentación incorrecta
SystemError	Problema interno del intérprete (no sale)
TypeError	Operación inválida para el tipo de dato especificado
ValueError	Argumentos de tipo válido pero valores inválidos
RuntimeError	Error generado que no cae en otra categoría
NotImplementedError	Método abstracto no implementado en clase heredada

Aserciones en Python

Una aserción es una comprobación de cordura que puedes activar o desactivar tras terminar las pruebas. Es similar a una sentencia raise-if-not: se evalúa una expresión y si es falsa, se lanza una excepción.

Las aserciones se realizan con la sentencia assert, introducida en Python 1.5. Los programadores suelen colocarlas al inicio de una función para validar entrada y tras una llamada para validar salida.

La Sentencia assert

Sintaxis: assert Expression[, Arguments]

Si la expresión es falsa, Python lanza AssertionError con el argumento opcional. Estas excepciones pueden capturarse con try-except.

Ejemplo

#!/usr/bin/python
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))

Resultado: lanza AssertionError: Colder than absolute zero! para -5.

¿Qué es una Excepción?

Una excepción es un evento que ocurre durante la ejecución y interrumpe el flujo normal de instrucciones. Cuando un script Python encuentra una situación que no puede manejar, lanza una excepción. Es un objeto Python que representa un error.

Si no se maneja, el script termina y sale.

Manejo de una Excepción

Para defender tu programa, coloca el código sospechoso en un bloque try: seguido de except: para manejar el problema.

Sintaxis

try:
    # Operaciones
except ExceptionI:
    # Manejo ExceptionI
except ExceptionII:
    # Manejo ExceptionII
else:
    # Si no hay excepción

Puntos clave:

• Un solo try puede tener múltiples except.
• Puedes usar except genérico para capturar cualquier excepción (no recomendado).
• El bloque else se ejecuta si no hay excepción.

Ejemplo: Escritura Exitosa

#!/usr/bin/python
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()

Ejemplo: Error de Permisos

#!/usr/bin/python
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")

Cláusula except Sin Excepciones Específicas

try:
    # Operaciones
except:
    # Captura cualquier excepción
else:
    # Sin excepción

Captura todas las excepciones pero no identifica la causa raíz; no es una buena práctica.

Cláusula except con Múltiples Excepciones

try:
    # Operaciones
except (Exception1, Exception2, ... ExceptionN):
    # Manejo para cualquiera de las excepciones listadas
else:
    # Sin excepción

Cláusula try-finally

El bloque finally: siempre se ejecuta, haya o no excepción.

try:
    # Operaciones
finally:
    # Siempre se ejecuta

Ejemplo

#!/usr/bin/python
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")

Argumento de una Excepción

Una excepción puede tener un argumento con información adicional. Se captura con una variable en la cláusula except:

except ExceptionType, Argument:
    print("Argument value:", Argument)

Ejemplo

#!/usr/bin/python
def temp_convert(var):
    try:
        return int(var)
    except ValueError as Argument:
        print("The argument does not contain numbers\n", Argument)

temp_convert("xyz")

Lanzar Excepciones (raise)

Sintaxis: raise [Exception [, args [, traceback]]]

Ejemplo

def functionName(level):
    if level < 1:
        raise "Invalid level!", level

Para capturar: except "Invalid level!":

Excepciones Definidas por el Usuario

Puedes crear tus propias excepciones derivando clases de las excepciones integradas.

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

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