Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 28 de 47 · Errores y funciones ✦ WebMCP implementado

Excepciones: try, except, else y finally

10 min de lectura 4 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.

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")
except ValueError as error:
    print("No es un número:", error)
    prioridad = 0

print("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
<?php
declare(strict_types=1);

function aEntero(string $texto): int
{
    if (!is_numeric($texto)) {
        throw new ValueError("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
def a_entero(texto):
    return int(texto)


try:
    prioridad = a_entero("abc")
except ValueError as error:
    print("No es un número:", error)
    prioridad = 0
finally:
    print("Fin del intento")
  1. catch (ValueError $error) pasa a except ValueError as error: sin paréntesis ni $, y el nombre va detrás de as (como).
  2. El mensaje no se pide con getMessage(): str(error) o, en un print o una f-string, el propio error.
  3. finally es idéntico: se ejecuta siempre, incluso si dentro hay un return.
  4. 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:

TipoCuándo saltaMensaje real
ValueErrorEl tipo es bueno, el valor no: int("abc")invalid literal for int() with base 10: 'abc'
KeyErrorUna clave que no existe en un dict'x' (solo la clave)
IndexErrorUna posición fuera de la listalist index out of range
ZeroDivisionErrorDividir entre cero: 1 / 0division by zero
TypeErrorMezclar tipos: "a" + 1can only concatenate str (not "int") to str
AttributeErrorPedir 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 padres
for 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.

PHP 8.5index.php
<?php
declare(strict_types=1);

try {
    throw new OutOfRangeException("fuera de rango");
} catch (LogicException $e) {
    echo "Un error de lógica: " . $e->getMessage() . PHP_EOL;
} catch (Exception $e) {
    echo "Una excepción cualquiera" . PHP_EOL;
} catch (Error $e) {
    echo "Un Error del motor: " . $e::class . PHP_EOL;
}
Pythonmain.py
try:
    raise IndexError("fuera de rango")
except LookupError as error:
    print("Un error de búsqueda:", error)
except Exception as error:
    print("Una excepción cualquiera")
PHPPythonQué atrapa
ThrowableBaseExceptionAbsolutamente todo, incluido salir con Ctrl+C
ExceptionExceptionLos errores «normales» del programa
Error (TypeError, DivisionByZeroError…)Exception y sus hijos (TypeError, ZeroDivisionError…)En Python no hay separación: todo es Exception
LogicException / RuntimeExceptionLookupError, 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
def convierte(texto):
    try:
        numero = int(texto)
    except ValueError:
        print(f"  {texto!r}: error")
        return None
    else:
        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 try solo 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)
except ValueError:
    prioridad = 0
else:
    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
class TareaNoEncontrada(Exception):
    pass


def buscar(tareas, id):
    for tarea in tareas:
        if tarea["id"] == id:
            return tarea
    raise TareaNoEncontrada(f"No existe la tarea {id}")


tareas = [{"id": 1, "titulo": "Comprar pan"}]

try:
    buscar(tareas, 1)
    buscar(tareas, 99)
except TareaNoEncontrada as error:
    print("Aviso:", error)
PHP 8.5index.php
<?php
declare(strict_types=1);

final class TareaNoEncontrada extends Exception
{
}

function buscar(array $tareas, int $id): array
{
    foreach ($tareas as $tarea) {
        if ($tarea["id"] === $id) {
            return $tarea;
        }
    }
    throw new TareaNoEncontrada("No existe la tarea $id");
}

try {
    buscar([["id" => 1]], 99);
} catch (TareaNoEncontrada $error) {
    echo "Aviso: " . $error->getMessage() . PHP_EOL;
}
Pythonmain.py
class TareaNoEncontrada(Exception):
    pass


def buscar(tareas, id):
    for tarea in tareas:
        if tarea["id"] == id:
            return tarea
    raise TareaNoEncontrada(f"No existe la tarea {id}")


try:
    buscar([{"id": 1}], 99)
except TareaNoEncontrada as 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
class TareaNoEncontrada(Exception):
    pass


repositorio = {1: "Comprar pan"}


def titulo_de(id):
    try:
        return repositorio[id]
    except KeyError as error:
        raise TareaNoEncontrada(f"No existe la tarea {id}") from error


try:
    titulo_de(5)
except TareaNoEncontrada as 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.

PHPPythonQuién lo ve
try { ... }try: + bloque sangradoEl 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 existeelse:Solo si el try no falló
throw new X("msg")raise X("msg")Sin new
new X("msg", 0, $previous)raise X("msg") from previousSe guarda en __cause__
$e->getMessage()str(e)El texto del error
extends Exceptionclass 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 = 3
if id in tareas:
    titulo = tareas[id]
else:
    titulo = "(no existe)"
print("LBYL:", titulo)

try:
    titulo = tareas[id]
except KeyError:
    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
def prioridad_de(tarea):
    try:
        return int(tarea["prioridad"])
    except Exception:
        return 0


# 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.

  1. Atrapa el tipo más concreto que esperas: except ValueError:.
  2. Mete en el try lo mínimo (y usa else para el resto).
  3. 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")
    except ValueError as error:
        error.add_note("al leer la prioridad de la tarea 7")
        raise
except ValueError as 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:
    raise ExceptionGroup("al guardar", [
        ValueError("prioridad inválida"),
        TypeError("título no es texto"),
    ])
except* ValueError as grupo:
    print("Valores:", [str(e) for e in grupo.exceptions])
except* TypeError as grupo:
    print("Tipos:", [str(e) for e in grupo.exceptions])

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

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

Resumen

Lo que te llevas de esta lección

  1. try / except / else / finally es el try / catch / finally de PHP, con else para «solo si no falló» y as en vez de $e.
  2. Exception es la rama normal; BaseException (como Throwable) incluye Ctrl+C y exit(): nunca escribas except: a secas.
  3. raise Error(...) es el throw new de PHP; raise ... from causa conserva el error original (el previous).
  4. Tus errores son clases vacías: class TareaNoEncontrada(Exception): pass (en PHP, extends Exception).
  5. 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».