«Garden Guardian»: el módulo de las excepciones. Cinco ejercicios, del rank 02,
que siguen en el huerto de los módulos anteriores — ahora lleno de sensores que fallan — y
enseñan try, except, raise, finally y las
excepciones propias. Módulo en curso: ex0 está hecho y explicado con su
código; del resto, esta ficha explica solo lo que pide el enunciado, y el código llegará cuando
esté terminado.
Estado: ex0 terminado (salida igual que el ejemplo del enunciado, mypy sin errores,
flake8 solo con W191 por las tabulaciones) · ex1 a medias (todavía no compila) ·
ex2–ex4 pendientes.
malloc devuelve NULL, open devuelve
-1 y deja el motivo en errno, y cada llamada exige su
if. Si se te olvida comprobarlo, el programa sigue como si nada hasta que
revienta más adelante. Las excepciones, que vienen de lenguajes como PL/I, CLU o Ada y se
popularizaron con C++ y Java, cambian el reparto: el código que detecta el problema
lanza (raise) un objeto que describe el error, y ese objeto sube por la
pila de llamadas hasta que alguien lo captura (except). Si nadie lo
hace, el intérprete para el programa e imprime el famoso traceback. Python va más
allá que la mayoría y usa excepciones para casi todo — hasta el final de un bucle
for es, por dentro, una StopIteration —, y su comunidad tiene un
lema para ello: EAFP, «es más fácil pedir perdón que permiso» (intentar y capturar)
frente a LBYL, «mira antes de saltar» (comprobarlo todo antes), que es el estilo de
C. Este módulo es el primero en el que una regla general dice que tus programas
no pueden romperse nunca.Las excepciones traen su propio vocabulario y un árbol de clases que conviene tener en la cabeza. Aquí está cada término explicado desde cero, con ejemplos del huerto de sensores del módulo (ninguno es la solución de un ejercicio). En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.
Un objeto que Python crea cuando algo no puede hacerse, y que describe qué ha fallado. Al
aparecer, el código normal se interrumpe en esa línea: no se ejecuta nada más del bloque hasta
que alguien la trate. Toda excepción tiene un tipo, que es su clase
(ValueError, KeyError…), y un mensaje. Si un sensor manda
"abc" como temperatura, int("abc") no devuelve ningún número: lanza un
ValueError con el mensaje «invalid literal for int() with base 10: 'abc'».
Una excepción que no se captura dentro de una función sale de ella y aparece en la línea que
la llamó, y así sucesivamente hacia arriba: main llama a
check_garden, que llama a read_sensor, que llama a int;
si int falla y nadie la captura por el camino, la excepción sube por las cuatro.
En cada nivel, el resto de la función se salta. Así la función que detecta el problema no tiene
que saber qué hacer con él: lo decide alguna de las que están más arriba.
El informe que imprime Python cuando una excepción llega hasta arriba sin que nadie la capture, justo antes de parar el programa. Se lee de abajo arriba: la última línea es el tipo y el mensaje, y encima está el camino de llamadas, de la más externa a la más interna:
$> python3 sensor.py
12
Traceback (most recent call last):
File "sensor.py", line 11, in <module>
check_garden()
File "sensor.py", line 7, in check_garden
print(read_sensor("error"))
File "sensor.py", line 2, in read_sensor
return int(raw)
ValueError: invalid literal for int() with base 10: 'error'
La primera lectura («12») salió bien; con la segunda, el programa murió y nunca llegó a sus líneas siguientes. En este módulo, ver un traceback al ejecutar un ejercicio es un fallo: la regla general es que el programa no puede romperse.
raiseLa palabra clave que crea una excepción a propósito, desde tu propio código:
raise TipoDeError("mensaje"). A partir de ahí se comporta igual que las que lanza
Python: interrumpe, se propaga y, si nadie la captura, acaba en traceback. Se usa cuando el
código detecta que algo no tiene sentido aunque Python no se queje, por ejemplo una altura de
planta negativa:
>>> raise ValueError("height can't be negative")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: height can't be negative
Elegir el tipo es parte del diseño: tiene que describir el problema, porque es lo que usará quien lo capture.
try / excepttry: abre un bloque de código «vigilado». Si dentro salta una excepción, Python
abandona el resto del bloque y busca debajo una rama except cuyo tipo encaje; si
la encuentra, ejecuta esa rama y el programa sigue después de todo el try, como si
nada. Si no encaja ninguna, la excepción sigue propagándose hacia arriba. Si no salta nada, las
ramas except no se ejecutan.
except … as e: el objeto excepciónas e le pone nombre a la excepción capturada para poder usarla dentro de la rama.
Es un objeto normal: print(e) o f"{e}" dan su mensaje,
type(e).__name__ el nombre de su clase y e.args la tupla con lo que se
le pasó al crearla. El nombre e solo existe dentro de esa rama
except.
else en un tryUna rama opcional, detrás de los except, que solo se ejecuta si el bloque
try terminó sin excepción. Sirve para dejar dentro del try solo la línea
que puede fallar y poner lo que depende de su éxito fuera de la vigilancia: así un error en esa
segunda parte no se confunde con el que se quería capturar.
finallyUna rama que se ejecuta siempre al salir del try: si todo fue bien, si
saltó una excepción capturada, si saltó una que nadie captura (se ejecuta y luego la excepción
sigue subiendo) y hasta si hay un return dentro del try. Es el sitio de
la limpieza que no puede depender de la suerte: cerrar el riego, cerrar un fichero, apagar un
sensor. El ejemplo general de la tarjeta «Qué pide» enseña el orden de las cuatro ramas.
BaseException → Exception → …Las excepciones son clases, y forman un árbol por herencia, como las plantas del Module 01. Un trozo de las que salen en el módulo:
BaseException
├── KeyboardInterrupt (Ctrl+C)
├── SystemExit (sys.exit())
└── Exception (todos los errores «normales»)
├── ValueError
├── TypeError
├── AttributeError
├── ArithmeticError
│ └── ZeroDivisionError
├── LookupError
│ ├── KeyError
│ └── IndexError
└── OSError
└── FileNotFoundError
Cada clase es también todas las que tiene encima: un ZeroDivisionError
es un ArithmeticError, un Exception y un BaseException.
Se puede comprobar en el intérprete:
>>> issubclass(ZeroDivisionError, ArithmeticError)
True
>>> issubclass(KeyboardInterrupt, Exception)
False
class Hija(Madre): crea una clase que hereda todo lo de la madre y añade lo suyo,
y un objeto de la hija cuenta también como objeto de la madre: una Flower es una
Plant. Las excepciones usan exactamente el mismo mecanismo, y por eso el árbol de
arriba decide qué atrapa cada except.
BaseException frente a ExceptionBaseException es la raíz de todo. Directamente debajo cuelgan, además de
Exception, unas pocas que no son errores sino señales: KeyboardInterrupt
(el usuario pulsa Ctrl+C) y SystemExit (el programa pide terminar). Por eso lo
habitual es capturar, como mucho, Exception: si capturas BaseException
o usas un except: sin tipo, también te tragas el Ctrl+C y el programa no se deja
parar.
ValueErrorEl valor tiene el tipo correcto pero un contenido que no vale. int() acepta
cadenas, pero la cadena "abc" no es un número. Es la excepción típica de los datos
de entrada malos: un sensor que manda basura en lugar de una lectura.
TypeErrorLa operación no tiene sentido con esos tipos, sea cual sea su valor: por ejemplo, mezclar en una misma operación el nombre de una planta (cadena) con su altura (número) cuando esos tipos no se combinan, o llamar a una función con argumentos de menos. Es justo lo que mypy intenta detectar antes de ejecutar.
ArithmeticError y ZeroDivisionErrorArithmeticError agrupa los fallos de cálculo. Su hija más conocida es
ZeroDivisionError: repartir el agua del depósito entre las plantas de un bancal que
tiene cero plantas. En C, dividir un entero entre cero es comportamiento indefinido (en Linux,
el programa muere con SIGFPE); en Python es una excepción que se puede capturar.
LookupError: KeyError e IndexErrorLookupError agrupa los fallos al buscar algo dentro de una colección.
KeyError: la clave no está en el diccionario. IndexError: la posición no
existe en la lista (de cada traceback se muestra solo la última línea):
>>> heights = {"Rose": 25.0, "Oak": 200.0}
>>> heights["Tulip"]
KeyError: 'Tulip'
>>> ["Rose", "Oak"][5]
IndexError: list index out of range
OSError y FileNotFoundErrorOSError es el error de una llamada al sistema operativo: en el fondo, el
errno de C convertido en objeto. Sus hijas dicen qué errno fue:
FileNotFoundError es el ENOENT (número 2, «No such file or
directory»), PermissionError el EACCES… Por eso su mensaje empieza por
[Errno 2]: es el mismo código que ves en C con perror. Le pasaría al
programa que intenta abrir el registro de riego de ayer y alguien lo ha borrado.
except Padre atrapa a los hijosUna rama except X encaja con cualquier excepción que sea una
X, es decir, de la clase X o de cualquiera de sus descendientes en el
árbol. Con un diccionario de alturas:
heights = {"Rose": 25.0, "Oak": 200.0}
try:
print(heights["Tulip"])
except LookupError as e:
print(f"Not in the garden: {e}")
Not in the garden: 'Tulip'
El KeyError se captura con except LookupError porque
KeyError es hija de LookupError; la misma rama atraparía un
IndexError. Cuanto más arriba en el árbol está la clase que pones, más cosas
atrapa: except Exception lo atrapa casi todo, que es cómodo pero esconde errores
que no esperabas. Lo mismo vale para las excepciones que defines tú.
except (KeyError, ValueError) as e: encaja si la excepción es de cualquiera de
los tipos de la tupla, aunque no tengan una madre común cercana. Es la otra forma de tratar
varios errores con un solo try, además de capturar a la madre común. Después se
puede seguir distinguiendo con más ramas except debajo.
exceptPython prueba las ramas de arriba abajo y ejecuta solo la primera que encaja. Si
pones except LookupError antes que except KeyError, la segunda no se
ejecutará nunca, porque todo KeyError ya habrá entrado en la primera. Regla
práctica: de lo más concreto (hijas) a lo más general (madres).
Una clase que defines tú heredando de Exception (o de otra excepción). Hereda todo
lo necesario para lanzarse, capturarse e imprimirse, y te deja nombrar los problemas de tu
dominio: un error «del huerto» dice más que un ValueError genérico, y quien lo
capture puede tratarlo aparte sin confundirlo con los errores de Python. Al ser clases, se pueden
organizar en su propio subárbol, y la regla de madre e hijas se
aplica igual.
Dos estilos de tratar los errores. LBYL («look before you leap», mira antes de
saltar): comprobar todo antes de actuar, como en C (if (fd == -1)…). EAFP
(«easier to ask for forgiveness than permission», es más fácil pedir perdón que permiso):
intentarlo y capturar el fallo. Para saber si una cadena es un número, en LBYL tendrías que
revisar carácter a carácter; en EAFP llamas a int() dentro de un try.
Python prefiere EAFP, y este módulo está escrito en ese estilo.
mypy lee el código sin ejecutarlo y comprueba que los tipos cuadran con las anotaciones. La
anotación de retorno (-> int) describe lo que la función devuelve cuando
termina bien; lanzar una excepción no es devolver, así que no cambia el tipo de retorno.
mypy tampoco comprueba qué excepciones lanza cada función: eso no forma parte del tipo en Python
(al contrario que en Java). Lo que sí detecta es una operación imposible con los tipos conocidos,
como mezclar una cadena y un número, sin necesidad de ejecutarla.
Las instrucciones generales del enunciado:
exN/.try/except. Las palabras
clave try, except, finally y raise no
cuentan como funciones autorizadas: se pueden usar siempre.ValueError,
TypeError, ZeroDivisionError, FileNotFoundError,
KeyError, IndexError, AttributeError, la clase base
Exception…).La sintaxis general que recorre el módulo, con un ejemplo que no tiene nada que ver con el huerto:
try:
valor = 10 / divisor # código que puede fallar
except ZeroDivisionError as e: # solo si falla con ese tipo
print(f"No se pudo: {e}")
else: # solo si no ha fallado
print(valor)
finally: # siempre, falle o no
print("fin")
Una función input_temperature(temp_str) que recibe una cadena, la convierte en
número y devuelve la temperatura como entero. Después, test_temperature() la
prueba con una entrada válida ("25") y otra inválida ("abc"),
captura el fallo, imprime un mensaje de error y demuestra que el programa sigue vivo. La
salida del ejemplo termina con «All tests completed - program didn't crash!».
def input_temperature(temp_str: str) -> int:
return int(temp_str)
def test_temperature() -> None:
print("=== Garden Temperature ===")
for data in ["25", "abc"]:
print()
print(f"Input data is '{data}'")
try:
temp = input_temperature(data)
print(f"Temperature is now {temp}°C")
except ValueError as error:
print(f"Caught input_temperature error: {error}")
print()
print("All tests completed - program didn't crash!")
if __name__ == "__main__":
test_temperature()
$> python3 ft_first_exception.py
=== Garden Temperature ===
Input data is '25'
Temperature is now 25°C
Input data is 'abc'
Caught input_temperature error: invalid literal for int() with base 10: 'abc'
All tests completed - program didn't crash!
Dos funciones con papeles separados. input_temperature no tiene ningún
try: llama a int() y, si la cadena no es un número, deja que el
ValueError salga de la función y aparezca en la línea
que la llamó (propagación). Su anotación sigue siendo
-> int: cuando devuelve, devuelve un entero; cuando falla, no devuelve nada,
lanza.
La captura está en test_temperature, que recorre las dos entradas del
enunciado con un for sobre una lista. Para cada una, el
try intenta convertir e imprimir. Con
"25" todo va bien y la rama except no se ejecuta. Con
"abc", la excepción salta en la primera línea del
bloque: Python abandona el resto (el print de «Temperature is now» no llega a
ejecutarse), salta a except ValueError as error y, al acabar la rama, sigue con la
siguiente vuelta del bucle. error es el objeto excepción, y
meterlo en una f-string da su mensaje: «invalid literal for int() with base 10: 'abc'». El
último print demuestra que el programa ha llegado vivo al final.
Captura ValueError y no Exception: de las dos opciones que da el
enunciado, la concreta. Los print() vacíos reproducen las líneas en blanco del
ejemplo, y la salida coincide con él línea a línea. mypy no da ningún error y flake8 solo avisa
de W191 (tabulaciones, a propósito).
int("a") parara el programa con un
ValueError) ahora hay que controlarlo. Es la primera vez que ves la excepción
como un objeto que se puede atrapar e imprimir: el texto del ejemplo, «invalid literal for
int() with base 10: 'abc'», es el mensaje que Python mete dentro del propio error. El
enunciado deja elegir entre capturar Exception a secas o averiguar qué excepción
concreta lanza la conversión; lo segundo es la costumbre buena.Se parte del ejercicio anterior. Ahora input_temperature además comprueba que
la temperatura sea razonable para las plantas, de 0 a 40 °C, límites incluidos:
si lo es la devuelve y, si no, lanza una excepción. Las pruebas añaden dos valores
extremos, "100" y "-50", con mensajes que dicen si hace demasiado
calor o demasiado frío y cuál es el límite. La parte principal del fichero llama a
test_temperature().
raise crea el error en el punto donde se detecta el
problema y deja que lo trate quien llamó, que es quien sabe qué hacer con él. Fíjate en que
"100" es un número perfectamente válido para int(): el error ya no es
de formato sino de regla de negocio, y aun así se captura en el mismo sitio y de la
misma forma.Una función garden_operations(operation_number) que contiene código
defectuoso a propósito: para cada valor de 0 a 3 provoca una excepción distinta —
ValueError (datos malos para int()), ZeroDivisionError,
FileNotFoundError (abrir un fichero que no existe) y TypeError
(mezclar tipos incompatibles, como sumar cadena y número). Con cualquier otro valor no hace
nada raro y simplemente vuelve. Luego test_error_types() provoca cada error, lo
captura, explica qué ha pasado, sigue adelante y enseña cómo capturar varios tipos con
un solo try.
La sintaxis para capturar varios tipos en la misma rama es una tupla:
except (KeyError, IndexError) as e:
...
Exception, y
FileNotFoundError es a su vez un caso particular de OSError, que es el
errno de C convertido en objeto (de ahí el «[Errno 2]» del mensaje). Capturar por
tipo permite reaccionar distinto a cada problema. El enunciado prohíbe usar
type() para distinguirlos: hay que dejar que except haga el trabajo.
Y avisa de algo curioso: mypy marcará como error la línea que provoca el
TypeError. Es justo su trabajo — detectar antes de ejecutar que estás sumando
una cadena y un número —, y aquí ese error se mantiene a propósito.Tres excepciones propias: GardenError, un error genérico del huerto que hereda
de Exception, y PlantError y WaterError, que heredan de
GardenError. Cada una tiene un mensaje por defecto propio (por
ejemplo «Unknown plant error») para cuando no se le pasa ninguno. Después, funciones que las
lancen en distintas situaciones, que muestren cómo capturar cada tipo concreto y que
demuestren que capturar GardenError atrapa todos los errores del huerto.
except GardenError atrapa también las
PlantError y las WaterError, porque una subclase es su clase
madre. Así un módulo puede ofrecer una familia de errores y quien lo use elige el nivel de
detalle. Las dos preguntas del enunciado van por ahí: cuándo merece la pena un error propio en
vez de uno predefinido, y cómo ayuda la herencia a organizarlos.Una función water_plant(plant_name) que «riega» la planta si su nombre está
capitalizado e imprime un mensaje de éxito; si no, lanza la PlantError del
ejercicio anterior. Y una función test_watering_system() que abre el sistema de
riego (basta con un mensaje), riega varias plantas con una estructura
try/except/finally y, si un nombre no es válido,
detiene la prueba y vuelve de inmediato a main. El sistema de riego se cierra
siempre en el bloque finally: el ejemplo muestra «Closing watering system» tanto
en la tanda válida como en la que falla a mitad.
free o el close (o a un goto hacia el final);
finally se ejecuta pase lo que pase: si el bloque termina normal, si salta una
excepción y hasta si hay un return dentro del try. Es la base de lo
que en el Module 04 hará la sentencia with por ti.> frente a >=.open() falla no hay
nada que cerrar; el propio enunciado lo recuerda.except. Python prueba las ramas de arriba abajo y usa
la primera que encaja: si except GardenError va antes que
except PlantError, la segunda nunca se ejecuta.str.capitalize(), así que el criterio es el de ese método: primera letra en
mayúscula y el resto en minúscula.try, cuándo crear tus propios errores y por qué limpiar aunque haya
fallos.Enunciado oficial en inglés, Garden Guardian — Data Engineering for Smart
Agriculture, versión 3.0: packs/cursus/M2/204_Python_Module_02/en.subject.pdf,
con el texto extraído en subject.txt en la misma carpeta.
Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado. Salen de las preguntas guía del propio enunciado. Las que tocan ejercicios aún sin hacer se responden con la teoría general, no con el código. Antes de mirar la respuesta, intenta contestar tú.
"abc"?int("abc") lanza un ValueError dentro de
input_temperature, que no lo captura, así que sale de la función y aparece en el
try de test_temperature. Se salta el print de la
temperatura, entra en except ValueError as error, imprime el mensaje y el bucle
continúa. → ex0, Propagación
try?El ValueError subiría hasta arriba sin que nadie lo capture: Python imprimiría
el traceback y pararía el programa, y «All tests completed» no saldría nunca. Es justo lo que
prohíbe la regla general del módulo. → Traceback
ValueError y no Exception, o un
except: a secas?Porque es la única que puede lanzar int() con una cadena, y capturar solo lo que
esperas deja ver los errores que no esperas. Exception lo atrapa casi todo (también
un error de escritura en tu código), y un except: sin tipo atrapa hasta el Ctrl+C.
→ BaseException, except Padre
Para que quien captura pueda reaccionar distinto a cada problema: un dato malo
(ValueError) se puede volver a pedir; un fichero que falta
(FileNotFoundError), crear o avisar. El tipo es la información, y el árbol permite
elegir el nivel de detalle. → Jerarquía, ex2
try?De tres formas: varias ramas except seguidas, una por tipo; una tupla de tipos
en una sola rama; o una rama con una clase madre común, que atrapa a todas sus hijas. En
cualquier caso, las ramas se prueban en orden y solo se ejecuta la primera que encaja.
→ Tupla, Orden, ex2
Porque el ejercicio pide provocar un TypeError a propósito, y mypy detecta sin
ejecutar que esa operación mezcla tipos incompatibles: está haciendo su trabajo. El enunciado
avisa de que ese aviso se queda. → mypy, Puntos
delicados
Porque un código de error se puede ignorar sin querer y el programa sigue con un valor malo; una excepción no: o alguien la captura o el programa para. Además separa el que detecta el problema del que sabe qué hacer, y deja libre el valor de retorno para el resultado bueno. → raise, ex1
Cuando el problema es de tu dominio y no encaja en uno predefinido, o cuando quien use tu código debe poder tratar tus errores aparte de los de Python. Organizados por herencia, se puede capturar uno concreto o la familia entera con la clase madre. → Excepción propia, ex3
finally y no al final del try?Porque si salta una excepción a mitad del try, el resto del bloque no se ejecuta
y la limpieza se perdería. finally se ejecuta siempre: con éxito, con error
capturado, con error sin capturar y hasta con return. → finally,
ex4
«Es más fácil pedir perdón que permiso»: intentar la operación y capturar el fallo, en vez de comprobarlo todo antes (LBYL, el estilo de C). En Python es natural porque las excepciones son baratas y el propio lenguaje las usa para todo. → EAFP