Python · Lección 25 de 27

Excepciones y errores

Los errores son inevitables: archivos que no existen, datos con formato incorrecto, divisiones por cero. La diferencia entre código amateur y profesional es cómo manejás esos errores. Con try/except, tu programa reacciona en vez de explotar.

80–100 min Prerrequisitos: 18 Funciones, 24 Archivos

Concepto teórico

¿Qué es una excepción?

Una excepción es un error que ocurre durante la ejecución del programa. Cuando Python encuentra un error, crea un objeto de excepción con información sobre qué salió mal. Si no lo "atrapás", el programa se detiene y muestra un traceback (la cadena de llamadas que llevó al error).

Tipos de errores comunes

Error	Cuándo ocurre	Ejemplo
`SyntaxError`	Código mal escrito (se detecta ANTES de ejecutar)	`if x = 5:` (falta ==)
`NameError`	Variable o función no definida	`print(xyz)` sin definir xyz
`TypeError`	Operación con tipo incorrecto	`"5" + 3` (str + int)
`ValueError`	Valor incorrecto para el tipo	`int("abc")`
`IndexError`	Índice fuera de rango	`lista[100]` en lista de 5
`KeyError`	Clave no existe en diccionario	`d["inexistente"]`
`ZeroDivisionError`	División por cero	`10 / 0`
`FileNotFoundError`	Archivo no existe	`open("no_existe.csv")`
`AttributeError`	Método/atributo no existe	`"hola".appendd()`

try / except / else / finally

try:
    # código que PUEDE fallar
    resultado = int(dato)
except ValueError:
    # se ejecuta SOLO si hay ValueError
    print("Dato no es un número")
except (TypeError, KeyError) as e:
    # capturar múltiples tipos
    print(f"Error: {e}")
else:
    # se ejecuta SOLO si NO hubo excepción
    print(f"Conversión exitosa: {resultado}")
finally:
    # se ejecuta SIEMPRE (haya o no error)
    print("Proceso terminado")

Regla de oro: except específico, nunca genérico. except: o except Exception: captura TODO, incluyendo errores que necesitás ver (como bugs en tu código). Siempre capturá el tipo de error específico que esperás: except ValueError:, except FileNotFoundError:, etc.

Anti-patrón mortal: try: ... except: pass. Esto silencia TODOS los errores. Tu programa "funciona" pero produce resultados incorrectos sin avisarte. Es el equivalente a tapar la luz de "check engine" con cinta. NUNCA uses except: pass.

raise — lanzar excepciones propias

raise te permite lanzar excepciones explícitamente cuando tu código detecta una condición inválida:

def depositar(saldo, monto):
    if monto <= 0:
        raise ValueError(f"Monto debe ser positivo, recibí: {monto}")
    return saldo + monto

EAFP vs LBYL

Dos filosofías para manejar errores:

LBYL (Look Before You Leap — mirá antes de saltar): verificá las condiciones ANTES de actuar. if "score" in dict: usar dict["score"]
EAFP (Easier to Ask Forgiveness than Permission — mejor pedir perdón que permiso): intentá directamente y capturá el error si falla. try: usar dict["score"] except KeyError: manejar

Python favorece EAFP. Es más pythónico, más eficiente (si el error es raro) y evita condiciones de carrera.

En análisis de datos: los errores de tipo y valor son el pan de cada día. Un CSV con un campo "N/A" donde esperás un número, una fecha en formato inesperado, un campo vacío. try/except ValueError te permite procesar miles de registros atrapando los errores uno a uno sin que todo el pipeline se caiga.

Ejemplos explicados paso a paso

Ejemplo 1: try/except básico

ejemplo_01_basico.pyPython

# Sin try/except: el programa explota
# print(10 / 0)  # ZeroDivisionError!

# Con try/except: manejamos el error
def dividir_seguro(a, b):
    try:
        resultado = a / b
    except ZeroDivisionError:
        print(f"  ⚠️ No se puede dividir {a} entre 0")
        return None
    else:
        print(f"  ✅ {a} / {b} = {resultado}")
        return resultado
    finally:
        print(f"  Operación registrada")

print("=== División segura ===")
dividir_seguro(100, 5)
print()
dividir_seguro(100, 0)

# Convertir datos con manejo de error
print("\n=== Conversión segura ===")
datos = ["42", "3.14", "abc", "100", "", "N/A"]
convertidos = []
errores = []

for d in datos:
    try:
        valor = float(d)
        convertidos.append(valor)
    except ValueError:
        errores.append(d)

print(f"Convertidos: {convertidos}")
print(f"Errores: {errores}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Capturar múltiples tipos de error

ejemplo_02_multiples.pyPython

# Función que puede fallar de varias formas
def obtener_dato(datos, clave, indice):
    try:
        lista = datos[clave]        # puede dar KeyError
        valor = lista[indice]       # puede dar IndexError
        resultado = float(valor)    # puede dar ValueError
        return resultado
    except KeyError:
        print(f"  ❌ Clave '{clave}' no existe")
    except IndexError:
        print(f"  ❌ Índice {indice} fuera de rango")
    except ValueError:
        print(f"  ❌ '{valor}' no es un número")
    except Exception as e:
        print(f"  ❌ Error inesperado: {type(e).__name__}: {e}")
    return None

datos = {
    "saldos": ["150000", "320000", "abc", "890000"],
    "scores": ["720", "680"],
}

print("=== Pruebas ===")
print(f"Normal: {obtener_dato(datos, 'saldos', 0)}")
print(f"KeyError: {obtener_dato(datos, 'emails', 0)}")
print(f"IndexError: {obtener_dato(datos, 'scores', 10)}")
print(f"ValueError: {obtener_dato(datos, 'saldos', 2)}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: raise y validación de datos

ejemplo_03_raise.pyPython

# raise: lanzar errores cuando los datos son inválidos
def validar_cliente(nombre, score, saldo):
    if not isinstance(nombre, str) or len(nombre) < 2:
        raise ValueError(f"Nombre inválido: '{nombre}'")
    if not isinstance(score, (int, float)) or score < 0 or score > 999:
        raise ValueError(f"Score fuera de rango: {score}")
    if saldo is None:
        raise TypeError("Saldo no puede ser None")
    return {"nombre": nombre, "score": score, "saldo": saldo, "valido": True}

# Probar con datos buenos y malos
pruebas = [
    ("García", 720, 150000),
    ("", 720, 150000),           # nombre vacío
    ("López", 1500, 320000),     # score > 999
    ("Pérez", 810, None),        # saldo None
]

print("=== Validación ===")
for nombre, score, saldo in pruebas:
    try:
        cliente = validar_cliente(nombre, score, saldo)
        print(f"  ✅ {cliente['nombre']}: OK")
    except (ValueError, TypeError) as e:
        print(f"  ❌ Error: {e}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Pipeline robusto con manejo de errores

ejemplo_04_pipeline.pyPython

# Pipeline que procesa registros con errores mezclados
registros = [
    "García|720|$150,000",
    "López|abc|$320,000",      # score no numérico
    "Martínez|590|",           # saldo vacío
    "Pérez|810|$890,000",
    "|645|$72,000",            # nombre vacío
    "Sosa|680|N/A",            # saldo N/A
]

def procesar_registro(linea, num_linea):
    campos = linea.split("|")
    if len(campos) != 3:
        raise ValueError(f"Se esperan 3 campos, hay {len(campos)}")
    
    nombre = campos[0].strip()
    if not nombre:
        raise ValueError("Nombre vacío")
    
    score = int(campos[1])  # puede dar ValueError si no es int
    
    saldo_str = campos[2].strip()
    if not saldo_str or saldo_str == "N/A":
        raise ValueError(f"Saldo inválido: '{saldo_str}'")
    saldo = float(saldo_str.replace("$", "").replace(",", ""))
    
    return {"nombre": nombre, "score": score, "saldo": saldo}

# Procesar con manejo de errores
validos = []
errores = []

for i, reg in enumerate(registros, 1):
    try:
        cliente = procesar_registro(reg, i)
        validos.append(cliente)
    except (ValueError, IndexError) as e:
        errores.append({"linea": i, "registro": reg, "error": str(e)})

print(f"✅ Válidos: {len(validos)}")
for c in validos:
    print(f"  {c['nombre']}: score {c['score']}, ${c['saldo']:,}")

print(f"\n❌ Errores: {len(errores)}")
for e in errores:
    print(f"  Línea {e['linea']}: {e['error']}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: EAFP vs LBYL y excepciones custom

ejemplo_05_eafp.pyPython

# LBYL: verificar TODO antes de actuar
def obtener_score_lbyl(cliente):
    if isinstance(cliente, dict):
        if "scoring" in cliente:
            if "valor" in cliente["scoring"]:
                return cliente["scoring"]["valor"]
    return None  # muchos niveles de if

# EAFP: intentar y pedir perdón
def obtener_score_eafp(cliente):
    try:
        return cliente["scoring"]["valor"]
    except (KeyError, TypeError):
        return None  # más limpio, mismo resultado

cliente_ok = {"nombre": "García", "scoring": {"valor": 720}}
cliente_mal = {"nombre": "López"}

print("LBYL:", obtener_score_lbyl(cliente_ok), obtener_score_lbyl(cliente_mal))
print("EAFP:", obtener_score_eafp(cliente_ok), obtener_score_eafp(cliente_mal))

# Excepción custom
class ScoreInsuficienteError(Exception):
    def __init__(self, score, minimo):
        self.score = score
        self.minimo = minimo
        super().__init__(f"Score {score} es menor al mínimo requerido ({minimo})")

def evaluar_credito(score, minimo=650):
    if score < minimo:
        raise ScoreInsuficienteError(score, minimo)
    return "Aprobado"

print("\n=== Excepción custom ===")
for score in [720, 590, 810, 480]:
    try:
        resultado = evaluar_credito(score)
        print(f"  Score {score}: {resultado}")
    except ScoreInsuficienteError as e:
        print(f"  Score {e.score}: ❌ {e}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Bloque	Cuándo se ejecuta	Obligatorio
`try`	Siempre (código que puede fallar)	Sí
`except TipoError`	Solo si ocurre ese tipo de error	Sí (al menos uno)
`else`	Solo si NO hubo error	No
`finally`	SIEMPRE (haya o no error)	No

Buena práctica	Mala práctica
`except ValueError:` (específico)	`except:` (captura TODO)
Loggear el error	`except: pass` (silenciar)
`raise` para datos inválidos	Devolver None o -1 silenciosamente
EAFP (try/except)	LBYL excesivo (if anidados)
Excepciones custom descriptivas	Mensajes genéricos "Error"

Ejercicios

Nivel 1 · Básico

Ejercicio 1: try/except con ValueError

Intentá convertir "abc" a int. Capturá el error e imprimí un mensaje amigable. Debe incluir no es un número.

ejercicio_01.pyDebe incluir "no es un número"

dato = "abc"

# Intentá convertir:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Capturar ZeroDivisionError

Creá una función dividir(a, b) que devuelva a/b o None si b es 0. Debe incluir None.

ejercicio_02.pyDebe incluir "None"

def dividir(a, b):
    pass  # completá

print(dividir(10, 3))
print(dividir(10, 0))

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: KeyError con .get() o try/except

Dado un dict sin clave "email", accedé de forma segura con try/except. Debe incluir no disponible.

ejercicio_03.pyDebe incluir "no disponible"

cliente = {"nombre": "García", "score": 720}

# Accedé a "email" de forma segura:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Convertir lista con errores

Dada ["42","3.14","abc","100","","N/A","55"], convertí a float los que se pueda, contá los errores. Debe incluir errores: 3.

ejercicio_04.pyDebe incluir "errores: 3"

datos = ["42", "3.14", "abc", "100", "", "N/A", "55"]
validos = []
errores = 0

# Convertí con try/except:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: raise para validación

Creá validar_monto(monto) que lance ValueError si es negativo o TypeError si no es número. Debe incluir ValueError.

ejercicio_05.pyDebe incluir "ValueError"

def validar_monto(monto):
    pass  # completá con raise

for m in [1500, -200, "abc", 0]:
    try:
        validar_monto(m)
        print(f"  ${m}: ✅")
    except (ValueError, TypeError) as e:
        print(f"  {m}: ❌ {type(e).__name__}: {e}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: try/except/else/finally completo

Creá una función que intente abrir un archivo, lo lea si existe, use else para confirmar éxito y finally para registrar que terminó. Debe incluir finally.

ejercicio_06.pyDebe incluir "finally"

def leer_archivo(nombre):
    try:
        with open(nombre) as f:
            contenido = f.read()
    except FileNotFoundError:
        print(f"  ❌ {nombre} no encontrado")
        contenido = None
    else:
        print(f"  ✅ Leídos {len(contenido)} caracteres")
    finally:
        print(f"  finally: operación terminada")
    return contenido

# Crear un archivo y probá:
with open("test.txt", "w") as f:
    f.write("Hola mundo")

leer_archivo("test.txt")
print()
leer_archivo("inexistente.txt")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Pipeline robusto

Procesá ["García|720|$150,000","López|abc|$320,000","Pérez|810|$890,000"] con try/except capturando errores por línea sin detener el pipeline. Debe incluir procesados.

ejercicio_07.pyDebe incluir "procesados"

registros = ["García|720|$150,000", "López|abc|$320,000", "Pérez|810|$890,000"]

# Procesá con manejo de errores:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Excepción custom

Creá class SaldoInsuficienteError(Exception) que se lance cuando intentás extraer más de lo que hay. Debe incluir SaldoInsuficiente.

ejercicio_08.pyDebe incluir "SaldoInsuficiente"

# Creá la excepción custom y una función extraer():

saldo = 100000
for monto in [30000, 50000, 80000]:
    try:
        pass  # llamá a extraer
    except Exception as e:
        print(f"  ❌ {type(e).__name__}: {e}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Retry pattern

Creá una función operar_con_retry(func, max_intentos=3) que reintente una operación hasta N veces si falla. Simulá una operación que falla aleatoriamente. Debe incluir intento.

ejercicio_09.pyDebe incluir "intento"

import random
random.seed(42)

def operacion_inestable():
    if random.random() < 0.6:
        raise ConnectionError("Timeout del servidor")
    return "Datos recibidos"

def con_retry(func, max_intentos=5):
    pass  # completá

resultado = con_retry(operacion_inestable)
print(f"Resultado: {resultado}")

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Sistema de procesamiento con logging de errores

Procesá 6 registros crudos: parseá, validá (score 0-999, saldo positivo), guardá los válidos en un JSON y los errores en un log. Debe incluir RESULTADO.

ejercicio_10_desafio.pyDebe incluir "RESULTADO"

import json

registros = [
    "García|720|$150,000",
    "López|abc|$320,000",
    "Martínez|590|",
    "Pérez|1200|$890,000",
    "Fernández|645|$72,000",
    "|680|$50,000",
]

validos = []
errores_log = []

# Pipeline completo con validación y manejo de errores:

print(f"=== RESULTADO ===")
print(f"Válidos: {len(validos)}")
print(f"Errores: {len(errores_log)}")

Hacé clic en ▶ Ejecutar

Resumen y conexión

try/except captura errores sin detener el programa. else se ejecuta si no hubo error. finally siempre.
SIEMPRE capturá excepciones específicas (except ValueError), nunca genéricas (except:).
raise lanza excepciones cuando tus datos son inválidos.
NUNCA uses except: pass — silencia bugs sin avisarte.
Python favorece EAFP (try/except) sobre LBYL (if anidados).
Las excepciones custom (class MiError(Exception)) hacen tu código más expresivo.

En la siguiente lección (26 · Clases y objetos intro) vas a aprender programación orientada a objetos: crear clases, instancias, métodos y herencia básica.

Recursos: Python docs — Errors · Built-in Exceptions

Hecho con ❤️ por Rodri Gonzalez