Cursus — Python Module 02 en curso

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

Del código de retorno a la excepción — En C, un error es un valor: 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.

GGlosario de teoría

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.

Qué es una excepción

Excepción

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'».

Propagación por la pila de llamadas

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.

Traceback

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.

Lanzar: raise

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

Capturar: try / except

try: 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ón

as 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 try

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

finally

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

El árbol de excepciones

La jerarquía: 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
Clase madre e hija (repaso del Module 01)

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 Exception

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

ValueError

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

TypeError

La 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 ZeroDivisionError

ArithmeticError 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 IndexError

LookupError 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 FileNotFoundError

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

Cómo se elige qué se captura

Un except Padre atrapa a los hijos

Una 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ú.

Varios tipos en una rama: la tupla

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.

El orden de las ramas except

Python 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).

Excepción propia

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.

Estilo y herramientas

EAFP frente a LBYL

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 y las anotaciones de una función que lanza

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.

Qué pide

Rank: 02Python: 3.10 o superiorObligatorio: flake8, mypyEjercicios: 5 (ex0–ex4)

Las instrucciones generales del enunciado:

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")

ex0ft_first_exception

Entrega: ex0/ft_first_exception.pyAutorizado: int(), print()

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

Qué te obliga a aprender — Lo que en el Module 00 era «el comportamiento esperado» (que 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.

ex1ft_raise_exception a medias

Entrega: ex1/ft_raise_exception.pyAutorizado: int(), print()

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().

Qué te obliga a aprender — Que no solo Python lanza excepciones: también tú. 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.

ex2ft_different_errors pendiente

Entrega: ex2/ft_different_errors.pyAutorizado: print(), open(), int()

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:
    ...
Qué te obliga a aprender — Que las excepciones forman una jerarquía de clases: todas las del ejercicio heredan de 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.

ex3ft_custom_errors pendiente

Entrega: ex3/ft_custom_errors.pyAutorizado: print()

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.

Qué te obliga a aprender — La herencia del Module 01 aplicada a algo útil. Una excepción propia es una clase como cualquier otra, y su lugar en el árbol decide quién la captura: 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.

ex4ft_finally_block pendiente

Entrega: ex4/ft_finally_block.pyAutorizado: print(), str.capitalize()

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.

Qué te obliga a aprender — Que liberar recursos no puede depender de que todo vaya bien. En C, cada salida anticipada de una función obligaba a repetir el 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.
Puntos delicados

Fuente

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.

?Preguntas probables de la evaluación

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

Lo básico

En ex0, ¿qué pasa exactamente cuando la entrada es "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

¿Y si quitas el 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

¿Por qué capturas 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

Tipos de error

¿Por qué Python tiene tipos distintos de error?

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

¿Cómo capturas varios tipos con un solo 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

¿Por qué mypy marca un error en ex2 y no lo arreglas?

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

Lanzar, errores propios y limpieza

¿Por qué lanzar una excepción en lugar de devolver un código de error, como en C?

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

¿Cuándo merece la pena crear tus propios errores?

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

¿Por qué limpiar en 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

¿Qué significa EAFP y por qué se dice que es «el estilo de Python»?

«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