Lección 28 de 47 · Errores y funciones✦ WebMCP implementado
Excepciones: try, except, else y finally
10 min de lectura4 retos
Cuando algo sale mal, tanto PHP como Python lanzan una excepción: un aviso que sube por el programa hasta que alguien lo atrapa. Aquí ves try, except, else y finally frente al try/catch/finally de PHP, cómo lanzas tus propios errores con raise y por qué en Python se prefiere «probar y, si falla, arreglarlo».
¿De dónde vienen los nombres?
except = inglés except (excepto, salvo)
«Haz esto, salvo que pase tal error». Es el catch de PHP: en vez de «atrapar», dice qué casos quedan fuera del camino normal.
raise = inglés raise (levantar, plantear)
Levantas la mano y dices «¡hay un problema!». Es el throw de PHP. Se habla de «levantar» una excepción.
finally = inglés finally (por último, al final)
El bloque que se ejecuta siempre al final, haya habido error o no. Igual que el finally de PHP.
EAFP = inglés Easier to Ask Forgiveness than Permission
«Es más fácil pedir perdón que pedir permiso»: probar y, si falla, tratar el error. Es el estilo de Python.
LBYL = inglés Look Before You Leap
«Mira antes de saltar»: comprobar antes de actuar (if + isset). Es el estilo que más se ve en PHP.
En 4 ideas
1/4
try / except / else / finally es el try / catch / finally de PHP, con una pieza extra: else corre solo si no hubo error.
Las excepciones forman un árbol: Exception es la rama normal y BaseException es la raíz, con cosas como KeyboardInterrupt. En PHP, el equivalente de la raíz es Throwable, con Exception y Error debajo.
raise TareaNoEncontrada(id) lanza (el throw new de PHP, sin new), y raise ... from error guarda la causa original, como el previous del constructor de las excepciones de PHP.
Python prefiere EAFP (probar y atrapar) a LBYL (comprobar antes con isset): es más corto y no hay hueco entre «comprobar» y «usar».
1 · try y except: el try/catch de Python
Una excepción es como una alarma de incendio: suena y, si nadie la apaga, el edificio entero (tu programa) se para. try es «voy a intentar esto» y except es la persona que sabe apagar esa alarma concreta.
Pythonmain.py
# En PHP: try { $n = (int) "abc"; } catch (...) {} (el cast no lanza nada)try:
prioridad = int("abc")
exceptValueErroras error:
print("No es un número:", error)
prioridad = 0print("Prioridad final:", prioridad)
Fíjate en lo que PHP no hace: (int) "abc" da 0 en silencio y tu programa sigue con un dato falso. Python protesta con un ValueError, y tú decides qué hacer.
PHP 8.5index.php
<?phpdeclare(strict_types=1);
functionaEntero(string $texto): int
{
if (!is_numeric($texto)) {
thrownewValueError("No es un número: $texto");
}
return (int) $texto;
}
try {
$prioridad = aEntero("abc");
} catch (ValueError $error) {
echo"No es un número: " . $error->getMessage() . PHP_EOL;
$prioridad = 0;
} finally {
echo"Fin del intento" . PHP_EOL;
}
Pythonmain.py
defa_entero(texto):
returnint(texto)
try:
prioridad = a_entero("abc")
exceptValueErroras error:
print("No es un número:", error)
prioridad = 0finally:
print("Fin del intento")
catch (ValueError $error) pasa a except ValueError as error: sin paréntesis ni $, y el nombre va detrás de as (como).
El mensaje no se pide con getMessage(): str(error) o, en un print o una f-string, el propio error.
finally es idéntico: se ejecuta siempre, incluso si dentro hay un return.
Un try necesita al menos un except o un finally; un try solo, no existe.
Cada error de Python tiene su tipo. Los que más verás en la app de tareas:
Tipo
Cuándo salta
Mensaje real
ValueError
El tipo es bueno, el valor no: int("abc")
invalid literal for int() with base 10: 'abc'
KeyError
Una clave que no existe en un dict
'x' (solo la clave)
IndexError
Una posición fuera de la lista
list index out of range
ZeroDivisionError
Dividir entre cero: 1 / 0
division by zero
TypeError
Mezclar tipos: "a" + 1
can only concatenate str (not "int") to str
AttributeError
Pedir algo que el objeto no tiene: None.titulo
'NoneType' object has no attribute 'titulo'
2 · El árbol de excepciones: Exception, BaseException y Throwable
Las excepciones son clases y están en un árbol familiar. Si atrapas a un padre, atrapas también a todos sus hijos. KeyError, por ejemplo, es hijo de LookupError (error de búsqueda), que es hijo de Exception.
Pythonmain.py
# En PHP: class_parents(new OutOfBoundsException()) devuelve la cadena de padresfor clase in (KeyError, IndexError, ValueError):
cadena = " > ".join(c.__name__ for c in clase.__mro__)
print(cadena)
print(issubclass(KeyError, LookupError))
print(issubclass(KeyboardInterrupt, Exception))
print(issubclass(KeyboardInterrupt, BaseException))
__mro__ es la lista de padres, del más cercano al más lejano. Todas terminan en BaseException y object.
try:
raiseIndexError("fuera de rango")
exceptLookupErroras error:
print("Un error de búsqueda:", error)
exceptExceptionas error:
print("Una excepción cualquiera")
PHP
Python
Qué atrapa
Throwable
BaseException
Absolutamente todo, incluido salir con Ctrl+C
Exception
Exception
Los errores «normales» del programa
Error (TypeError, DivisionByZeroError…)
Exception y sus hijos (TypeError, ZeroDivisionError…)
En Python no hay separación: todo es Exception
LogicException / RuntimeException
LookupError, ArithmeticError, OSError…
Familias de errores parecidos
¿Por qué? · En PHP no existe
¿Por qué BaseException está por encima de Exception?
Hay avisos que no son un fallo de tu código: KeyboardInterrupt (alguien pulsa Ctrl+C), SystemExit (el programa llama a exit()) y GeneratorExit. Si estuvieran dentro de Exception, un except Exception: los atraparía y no podrías parar tu programa.
En PHP, catch (Throwable) lo atrapa todo, y por eso es peligroso. Python te da la rama Exception como la forma segura de decir «cualquier fallo normal», y deja BaseException para quien de verdad quiera todo (casi nunca).
3 · else y finally: el camino feliz y la limpieza
Python añade una pieza que PHP no tiene: else, que se ejecuta solo si el try terminó sin errores. El orden completo es: try (intento), except (si falla), else (si no falló) y finally (siempre).
Pythonmain.py
defconvierte(texto):
try:
numero = int(texto)
exceptValueError:
print(f" {texto!r}: error")
returnNoneelse:
print(f" {texto!r}: ok")
return numero
finally:
print(" (fin del intento)")
print(convierte("7"))
print(convierte("siete"))
El finally se ejecuta incluso con return dentro: Python guarda el valor, ejecuta el finally y entonces devuelve. Por eso en la salida ves «fin del intento» antes del resultado.
¿Por qué? · En PHP no existe
¿Para qué sirve else, si podría poner ese código dentro del try? En PHP no existe
Todo lo que escribes dentro del try queda vigilado: si falla cualquier línea, salta el except. Eso es un problema cuando una línea de abajo lanza un error que no esperabas del mismo tipo y lo tapas por error.
else deja dentro del trysolo la línea que sabes que puede fallar y pone lo demás fuera de la vigilancia. Así un fallo de verdad en la segunda parte no se confunde con el que esperabas.
Pythonmain.py
# Vigilas solo la conversión; lo demás queda fuera.try:
prioridad = int(texto)
exceptValueError:
prioridad = 0else:
guardar(prioridad)
4 · raise, raise from y tus propias excepciones
Lanzar una excepción es raise. Y para que el error diga qué pasó en tu app, creas el tuyo: una clase vacía que hereda de Exception. Es el class TareaNoEncontrada extends Exception {} de PHP.
Pythonmain.py
classTareaNoEncontrada(Exception):
passdefbuscar(tareas, id):
for tarea in tareas:
if tarea["id"] == id:
return tarea
raiseTareaNoEncontrada(f"No existe la tarea {id}")
tareas = [{"id": 1, "titulo": "Comprar pan"}]
try:
buscar(tareas, 1)
buscar(tareas, 99)
exceptTareaNoEncontradaas error:
print("Aviso:", error)
classTareaNoEncontrada(Exception):
passdefbuscar(tareas, id):
for tarea in tareas:
if tarea["id"] == id:
return tarea
raiseTareaNoEncontrada(f"No existe la tarea {id}")
try:
buscar([{"id": 1}], 99)
exceptTareaNoEncontradaas error:
print("Aviso:", error)
Cuando atrapas un error de abajo y lanzas uno tuyo, no pierdas el original. En PHP lo pasas como previous; en Python escribes raise ... from:
Pythonmain.py
classTareaNoEncontrada(Exception):
pass
repositorio = {1: "Comprar pan"}
deftitulo_de(id):
try:
return repositorio[id]
exceptKeyErroras error:
raiseTareaNoEncontrada(f"No existe la tarea {id}") from error
try:
titulo_de(5)
exceptTareaNoEncontradaas error:
print("Error:", error)
print("Causa:", repr(error.__cause__))
¿Por qué? · En PHP no existe
¿Por qué raise ... from error? En PHP lo hace el segundo argumento del constructor
El error de abajo (KeyError) habla el idioma del diccionario; el de arriba (TareaNoEncontrada) habla el de tu app. Quien lo atrape quiere el segundo, pero tú, al depurar, necesitas el primero.
from error guarda el original en __cause__ y, si el programa se rompe, Python imprime los dos seguidos («The above exception was the direct cause of…»). En PHP lo mismo se hace con new TareaNoEncontrada("…", 0, $error) y getPrevious().
Equivalencia POO · PHP → Python
El try/catch de PHP, traducido pieza a pieza.
PHP
Python
Quién lo ve
try { ... }
try: + bloque sangrado
El bloque vigilado
catch (Tipo $e)
except Tipo as e:
Solo ese tipo y sus hijos
catch (A | B $e)
except (A, B) as e:
Cualquiera de los dos, en una tupla
finally { ... }
finally:
Siempre, aunque haya return
No existe
else:
Solo si el try no falló
throw new X("msg")
raise X("msg")
Sin new
new X("msg", 0, $previous)
raise X("msg") from previous
Se guarda en __cause__
$e->getMessage()
str(e)
El texto del error
extends Exception
class X(Exception):
Tu error propio, en la rama normal
5 · EAFP frente a LBYL: pedir perdón, no permiso
Hay dos maneras de cruzar una calle. LBYL: miras a los dos lados y, si no viene nadie, cruzas. EAFP: cruzas y, si viene un coche, lo esquivas. En PHP casi siempre se mira antes (isset, array_key_exists); en Python se prefiere cruzar y atrapar.
Pythonmain.py
tareas = {1: "Comprar pan", 2: "Llamar al banco"}
# En PHP: $titulo = isset($tareas[$id]) ? $tareas[$id] : "(no existe)";
id = 3if id in tareas:
titulo = tareas[id]
else:
titulo = "(no existe)"print("LBYL:", titulo)
try:
titulo = tareas[id]
exceptKeyError:
titulo = "(no existe)"print("EAFP:", titulo)
print("get:", tareas.get(id, "(no existe)"))
¿Por qué? · En PHP no existe
¿Por qué Python prefiere EAFP? En PHP se mira antes
1. Hay un hueco entre mirar y usar. Con if id in tareas: otro hilo o proceso puede borrar la tarea justo después de comprobarlo. Con EAFP no hay hueco: el intento es la comprobación.
2. Es más corto cuando casi siempre sale bien. Si el 99 % de las veces la clave existe, no pagas una búsqueda de más.
3. Comprobar todo es imposible. Para saber si un fichero se puede abrir tendrías que mirar permisos, espacio y si existe. Intentarlo y atrapar OSError lo resume.
6 · El error número uno: except demasiado ancho
Mira este código. Parece inocente y esconde un bug que cuesta horas encontrar:
Pythonmain.py
defprioridad_de(tarea):
try:
returnint(tarea["prioridad"])
exceptException:
return0# La clave se llama "prioridad", pero aquí hay una errata.print(prioridad_de({"prioridad": "3"}))
print(prioridad_de({"prioridd": "3"}))
La segunda llamada debería haber fallado a gritos con un KeyError (errata en la clave). Pero except Exception se lo traga y devuelve 0 como si nada. Esto es el equivalente a un @ delante de una función de PHP, o a un try { ... } catch (Throwable) {} vacío.
Atrapa el tipo más concreto que esperas: except ValueError:.
Mete en el trylo mínimo (y usa else para el resto).
Si atrapas algo ancho para registrarlo, vuelve a lanzarlo con raise al final.
7 · add_note y ExceptionGroup (3.11)
Dos novedades de Python 3.11 que PHP no tiene. add_note() pega una nota a una excepción que ya has atrapado, para dar más contexto al volver a lanzarla:
Pythonmain.py
try:
try:
int("abc")
exceptValueErroras error:
error.add_note("al leer la prioridad de la tarea 7")
raiseexceptValueErroras error:
print(error)
print(error.__notes__)
Y ExceptionGroup junta varios errores en uno (útil cuando haces varias cosas a la vez y fallan varias; lo verás en el módulo 08). Se atrapa con except*, que reparte cada error al except* que le toca:
Pythonmain.py
try:
raiseExceptionGroup("al guardar", [
ValueError("prioridad inválida"),
TypeError("título no es texto"),
])
except* ValueErroras grupo:
print("Valores:", [str(e) for e in grupo.exceptions])
except* TypeErroras grupo:
print("Tipos:", [str(e) for e in grupo.exceptions])
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Número o cero
Escribe a_entero(texto): devuelve el número entero que dice el texto o 0 si no es un número. Es el intval() de PHP, pero atrapando el error en vez de callarlo.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Pon el return int(texto) dentro de un try y atrapa ValueError (no Exception) para devolver 0.
Reto 2 de 4 · ✓ Resuelto
Separa lo bueno de lo malo
Escribe lee_prioridades(textos): recibe una lista de textos y devuelve una tupla (validas, fallos), donde validas es la lista de enteros que sí se pudieron convertir y fallos es cuántos no. Usa try, except y else. Ejemplo: lee_prioridades(["1", "x", "3"]) devuelve ([1, 3], 1).
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Dentro del for: try con int(texto), except ValueError suma uno a fallos y else añade el número a validas.
Reto 3 de 4 · ✓ Resuelto
La tarea que no existe
Ya tienes la clase TareaNoEncontrada. Escribe titulo_de(tareas, id): tareas es un diccionario {id: titulo}. Si el id existe, devuelve su título; si no, lanza TareaNoEncontradaconservando el KeyError original con raise ... from. Es el throw new TareaNoEncontrada(..., previous: $e) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Usa tareas[id] (que lanza KeyError), atrápalo y lanza TareaNoEncontrada(...) con from error. El mensaje debe incluir el id.
Reto 4 de 4 · ✓ Resuelto
Siempre cerrar la tarea
Escribe procesa(tarea, pasos): pasos es una lista de funciones que reciben la tarea. Ejecuta cada una en orden. Si alguna lanza ValueError, para y devuelve "fallo"; si todas van bien, devuelve "ok". Pase lo que pase, añade "cerrada" a la lista tarea["log"] (para eso va finally). Es el try/catch/finally de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.try con el bucle, except ValueError devuelve "fallo", else devuelve "ok" y finally añade "cerrada" al log.
Resumen
Lo que te llevas de esta lección
try / except / else / finally es el try / catch / finally de PHP, con else para «solo si no falló» y as en vez de $e.
Exception es la rama normal; BaseException (como Throwable) incluye Ctrl+C y exit(): nunca escribas except: a secas.
raise Error(...) es el throw new de PHP; raise ... from causa conserva el error original (el previous).
Tus errores son clases vacías: class TareaNoEncontrada(Exception): pass (en PHP, extends Exception).
EAFP: prueba y atrapa el error concreto; un except Exception ancho se traga los bugs.
Para recordarlo: «Tengo Esa Eterna Fobia»
TTry try: lo que puede fallar
EExcept except Tipo as e: solo el concreto
EElse else: si no falló
FFinally finally: siempre
El orden de un try completo, de arriba abajo: Try · Except · Else · Finally. Y una regla corta: «atrapa el error concreto, nunca el ancho».