Módulos y depuración en Python: pruebas y aserciones

Un módulo contiene código Python que otro programa puede reutilizar. La mayoría de los módulos son archivos .py. La biblioteca estándar viene con Python; el código de terceros requiere una instalación aparte. Un paquete agrupa módulos relacionados, normalmente en una carpeta.

Haz que la llamada coincida con la importación

Una importación crea nombres en tu programa. La forma que eliges determina cómo llamas al código importado.

La notación de punto consiste en buscar un nombre dentro de un módulo u objeto. En math.sqrt(16), Python encuentra sqrt dentro de math y la llama con 16. El resultado es 4.0. La constante math.pi no necesita paréntesis de llamada porque es un valor, no una función.

Después de import math, usar solo sqrt(16) lanza NameError: el programa tiene un nombre para el módulo, pero no un nombre independiente para sqrt. Después de usar únicamente from math import sqrt, el error inverso, math.sqrt(16), también lanza NameError porque math no se ha vinculado. Un alias sustituye el nombre habitual de la vinculación importada: import statistics as stats crea stats, no ambos nombres.

Resuelve el mismo cálculo de dos formas

Un triángulo rectángulo tiene catetos de 3 y 4. Primero eleva al cuadrado los catetos y suma los resultados; después calcula la raíz cuadrada.

import math

length = math.sqrt(3**2 + 4**2)
print(length)  # 5.0

La expresión dentro de la llamada se convierte en 9 + 16 y después en 25; sqrt devuelve 5.0. Con from math import sqrt, escribe en su lugar length = sqrt(3**2 + 4**2). Usar el prefijo del módulo permite ver de dónde procede una función y mantiene sus demás nombres fuera del espacio de nombres de tu programa. La propia vinculación math sí puede sustituir una variable anterior llamada math.

Mantén claros los nombres

Evita from math import *. Esta importación con comodín incorpora nombres públicos a tu programa sin nombrarlos individualmente. Por ejemplo, e = 5 seguido de esa importación cambia e a 2.718281828459045. Una importación que parece no tener relación puede, por tanto, cambiar un cálculo posterior. PEP 8 recomienda importaciones explícitas y las coloca al principio, con un módulo por línea: primero la biblioteca estándar, después los paquetes de terceros y, por último, tus propios módulos.

Python ejecuta el código de nivel superior de un módulo en su primera importación durante una ejecución del programa. Las importaciones posteriores reutilizan el módulo cargado; no vuelven a iniciarlo.

Usa el error para elegir la solución

En la consola interactiva, ejecuta import math y después dir(math) para enumerar sus nombres. Ejecuta help(math.sqrt) para leer la documentación de una función. La referencia oficial de la biblioteca de Python explica sus argumentos y su resultado.

La biblioteca estándar proporciona herramientas probadas para cálculos y simulaciones. Para elegir una función, empieza por el resultado que necesitas: un recuento entero, una medida redondeada, un elemento aleatorio o una lista reordenada.

Redondear tiene varios significados

Después de import math, math.sqrt(16) devuelve el número de coma flotante 4.0. math.pi y math.e proporcionan las constantes 3.141592653589793 y 2.718281828459045. math.factorial(5) multiplica los enteros de 1 a 5 y devuelve 120.

Para una pared de 23 metros cuadrados y 10 metros cuadrados por lata de pintura, la división da 2.3 latas. Comprar latas enteras requiere math.ceil(23 / 10), que devuelve 3. round(2.3) da 2 y deja una cantidad de pintura insuficiente.

La función incorporada round() no necesita ninguna importación. Para un círculo de radio 2, round(math.pi * 2 ** 2, 2) da 12.57. El redondeo cambia la precisión de un número; es una tarea distinta de comprar suficientes recipientes enteros.

Comprueba dominios y comparaciones de números de coma flotante

math.sqrt(-1) lanza ValueError porque no hay una raíz cuadrada real para esa entrada. Los números de coma flotante calculados también requieren cuidado: su almacenamiento en binario hace que 0.1 + 0.2 == 0.3 sea False. math.isclose(0.1 + 0.2, 0.3) es True; úsalo para comparar de forma aproximada números de coma flotante calculados.

Selecciona la operación aleatoria

El módulo random utiliza un algoritmo para producir resultados pseudoaleatorios.

Mantén random.shuffle(cards) en su propia línea. Asignar su resultado de nuevo a cards pierde la vinculación con la lista al sustituirla por None. Muestrear posiciones también es distinto de exigir valores diferentes: random.sample([1, 1], 2) devuelve [1, 1].

Ejecuta una simulación reproducible

import random

sevens = 0
for _ in range(1000):
    if random.randint(1, 6) + random.randint(1, 6) == 7:
        sevens += 1
print(sevens)

Seis de los 36 pares equiprobables suman 7, por lo que el recuento suele estar cerca de 167, pero cambia entre ejecuciones. Para reproducir una secuencia durante la depuración, llama a random.seed(42) antes de generar los valores, usando la misma versión de Python y la misma secuencia de llamadas. Para contraseñas o tokens de seguridad, usa secrets.

Encuentra otras herramientas de uso habitual

statistics.mean([2, 4, 9]) devuelve 5; statistics.median([2, 4, 9]) devuelve 4. datetime.date.today() da la fecha de hoy. Después de import sys, sys.argv contiene el nombre del archivo de programa seguido de sus argumentos: ejecutar python greet.py Ada proporciona ['greet.py', 'Ada'].

Una función es más fácil de reutilizar cuando está en un módulo centrado en una tarea. Otro programa puede importar esa función, y una prueba puede comprobarla sin pedir a una persona que ejecute toda la aplicación.

Separa la función del código que la llama

Guarda este código como geometry.py:

"""Calculations for simple shapes."""
import math

def circle_area(radius):
    """Return the area of a circle with the given radius."""
    return math.pi * radius ** 2

En la misma carpeta, guarda este código que realiza la llamada como main.py:

import geometry

print(geometry.circle_area(2))

Ejecuta python main.py. Python encuentra geometry, crea su función y después el código que realiza la llamada ejecuta esa función. El resultado mostrado es 12.566370614359172. Importa sin la terminación .py. Un nombre de módulo válido usa letras, dígitos y guiones bajos con un primer carácter válido; my_tools.py funciona con import my_tools, mientras que import my-tools es sintaxis no válida.

Las cadenas situadas al principio del módulo y de la función son cadenas de documentación. Describen el propósito del código y aparecen en help(geometry) y help(geometry.circle_area).

Comprende qué ejecuta una importación

En la primera importación, Python ejecuta por orden las sentencias de nivel superior del módulo. Una sentencia def crea una función; no ejecuta el cuerpo de esa función. Sin embargo, un print(circle_area(2)) sin condición de protección al final de geometry.py mostraría su salida durante la importación.

Ese efecto secundario importa cuando un módulo contiene solicitudes de datos o un bucle del programa. Una prueba que solo necesita circle_area no debería tener que iniciar el programa y responder a sus solicitudes.

Protege el inicio y mantén disponible la función

Añade esto debajo de la función reutilizable en geometry.py:

def main():
    print(circle_area(2))

if __name__ == "__main__":
    main()

Python establece __name__ para cada módulo. Una ejecución directa, python geometry.py, lo establece en "__main__", por lo que la condición es verdadera y se llama a main(). Importar geometry lo establece en "geometry", así que Python omite la llamada. Las definiciones situadas antes de la condición de ejecución directa siguen disponibles en ambos casos.

No coloques la propia circle_area dentro de la condición de ejecución directa. El código que importa necesita esa definición incluso cuando la condición de inicio es falsa. La condición controla cuándo se inicia la aplicación; no impide que Python cargue el módulo.

Conoce dónde busca Python

Python comprueba módulos integrados como sys y después las carpetas de sys.path, por orden. Normalmente, la carpeta del archivo de programa en ejecución aparece primero en esa ruta, seguida de las carpetas de la biblioteca estándar y de los paquetes instalados. Mantener tus propios archivos junto al archivo de programa que ejecutas es una organización sencilla para un proyecto de principiante. Una importación normal no puede encontrar un módulo situado fuera de la ruta de búsqueda.

Este orden también puede ocultar un módulo de biblioteca. Si guardas tu programa como random.py, su import random puede cargar tu archivo en lugar de la biblioteca. Una llamada posterior a random.randint(1, 6) lanza entonces AttributeError. Cambia el nombre del archivo, por ejemplo, a dice.py; Python 3.13 y versiones posteriores pueden incluir en el error una sugerencia para cambiar el nombre.

Un módulo cargado se reutiliza dentro de la misma ejecución. En una consola interactiva, editar el archivo y volver a importarlo mantiene la versión cargada. Reinicia la consola antes de probar tus cambios.

Los paquetes de terceros añaden código que no viene con Python. PyPI, el Python Package Index en https://pypi.org, aloja estos proyectos. pip los descarga e instala para una instalación concreta de Python.

Usa la terminal y después Python

Un comando de terminal y una sentencia de Python se escriben en lugares distintos. El indicador >>> significa que estás en la consola interactiva de Python. Introducir pip install requests allí genera SyntaxError; Python no puede interpretarlo como una sentencia.

En tu terminal, ejecuta:

python -m pip install cowsay

Después, pon esto en un programa de Python:

import cowsay

cowsay.cow("Hello, Ada")

El programa muestra una vaca hecha con texto junto a un globo de diálogo que contiene el mensaje. La instalación hace que el paquete esté disponible; la importación crea la vinculación del programa con él.

Haz que pip corresponda a tu intérprete

La forma -m pip pide al Python indicado que ejecute su propio pip. Usa el comando que inicia tus programas: a menudo, python3 en macOS o Linux, o py en Windows.

python3 -m pip install cowsay
python3 game.py

Ambas líneas seleccionan el mismo comando de Python. Si una instalación informa de que ha terminado correctamente, pero un archivo de programa sigue lanzando ModuleNotFoundError, compara el Python usado para instalar con el usado para ejecutar el archivo. Un editor puede haber seleccionado un intérprete distinto del de tu terminal. Usa el pip del intérprete seleccionado antes de cambiar la importación.

Inspecciona y mantén una instalación

Una versión exacta resulta útil cuando necesitas el comportamiento de esa versión concreta. show ayuda a comprobar qué ubicación ha modificado realmente pip.

Comprueba el nombre en la documentación

El nombre de distribución escrito para pip puede diferir del nombre de importación. Instala beautifulsoup4 y después usa import bs4; instala Pillow y después usa import PIL. Instalar repetidamente un nombre de importación no es una solución útil cuando la documentación indica otra distribución.

La biblioteca estándar de Python, incluidos math, random y unittest, ya viene con Python. Estos módulos no requieren una instalación con pip.

Respeta una instalación gestionada

Algunos sistemas operativos y gestores de paquetes protegen su Python con un error externally-managed-environment. Esto significa que se bloquea la instalación directa para mantener la coherencia de la instalación gestionada. Usa un entorno virtual, una carpeta independiente con Python y paquetes para el proyecto. No fuerces la instalación con sudo pip install.

Cualquiera puede publicar en PyPI. Antes de instalar, comprueba la escritura exacta del nombre y lee la página y la documentación del proyecto. Los nombres parecidos pueden ser intentos de suplantación mediante nombres similares. Da preferencia a paquetes consolidados que reciban mantenimiento e instala los que tu programa necesita realmente.

Una traza de excepción indica qué llamadas estaban activas cuando una excepción no manejada detuvo el programa. Ofrece tanto un lugar por el que empezar a leer como un camino de vuelta hacia el valor que causó el fallo.

Empieza por la última línea

Considera este programa completo en scores.py:

def average(values):
    return sum(values) / len(values)

def report(scores):
    avg = average(scores)
    print(f"Average: {avg:.1f}")

report([])

La última línea de su informe de error es ZeroDivisionError: division by zero. Indica el tipo de excepción y describe la operación que ha fallado. Empieza ahí y después lee hacia arriba hasta la ubicación del código inmediatamente anterior.

Una traza simplificada, sin las marcas de expresión, es:

Traceback (most recent call last):
  File "scores.py", line 8, in <module>
    report([])
  File "scores.py", line 5, in report
    avg = average(scores)
  File "scores.py", line 2, in average
    return sum(values) / len(values)
ZeroDivisionError: division by zero

Lee cada marco como una llamada activa

Un marco de ejecución indica el archivo, el número de línea y la función, seguidos del código correspondiente. in <module> significa código de nivel superior. La llamada más antigua está arriba; la más reciente, abajo. Leer desde abajo invierte ese orden para que puedas averiguar qué ha fallado antes de preguntar cómo ha llegado allí la ejecución.

1. La línea 2 divide entre len(values). Para que ese divisor sea cero, values debe estar vacío.
2. La línea 5 llama a average(scores), así que inspecciona el scores que pasa report.
3. La línea 8 proporciona [], la lista vacía. Eso explica cómo ha llegado el divisor cero al cálculo.

La línea que falla y la causa están relacionadas, pero pueden encontrarse en lugares distintos. Sustituir la división sin decidir qué debe significar una lista vacía ocultaría la cuestión de diseño. El código que realiza la llamada debe evitar una lista vacía o la función necesita un comportamiento definido para una entrada vacía.

Usa las marcas sin depender de su forma exacta

Python 3.11 y versiones posteriores pueden añadir marcas ^ y ~ para mostrar la parte de una expresión que falla. Ayudan cuando una línea contiene varias operaciones. Las marcas exactas varían entre versiones, pero las ubicaciones de las llamadas y el mensaje de excepción siguen indicando el orden de lectura.

Una traza puede contener marcos de la biblioteca estándar o de un paquete instalado. Busca el marco más bajo de tu propio código e inspecciona los argumentos que has proporcionado allí. Un marco de biblioteca es una pista de ubicación; no demuestra que la biblioteca contenga el error.

Reconoce un informe de sintaxis

Un error de sintaxis en el archivo de programa que se inicia impide que ese archivo se ejecute. Python informa de un archivo, una línea, una marca y un mensaje sin la cabecera habitual de la traza. Por ejemplo, a if True le faltan los dos puntos; total = sum([1, 2, 3] deja un paréntesis abierto.

El lugar marcado es donde Python ha detectado que no podía analizar el código. Cuando esa línea parece válida, revisa la anterior en busca de una comilla o un paréntesis sin cerrar. No hay una cadena de llamadas en ejecución que seguir cuando el archivo de programa inicial no ha llegado a ejecutarse.

Una ejecución normal se detiene en su primera excepción no manejada. Corrige ese problema y vuelve a ejecutar para descubrir cualquier problema posterior del programa.

El nombre de un error acota la búsqueda, y su mensaje añade detalles sobre los valores implicados. Un programa también puede ser incorrecto sin lanzar una excepción, por lo que comprobar la salida esperada sigue siendo parte de la detección de errores.

Distingue tres tipos de problema

IndentationError es un tipo de SyntaxError. El cuerpo de una función necesita sangría; la ausencia de un bloque con sangría detiene el código antes de que se ejecute. Revisa también las comillas o los paréntesis sin cerrar y las palabras reservadas mal escritas.

Lee con atención los nombres y los tipos

Un NameError significa que el programa no conoce un nombre en ese punto. En prnt("hi"), la función incorporada que se pretendía usar es print. También puede haberse usado un nombre antes de asignarle un valor o puede faltar una importación.

Un TypeError significa que una operación ha recibido un tipo inadecuado o que una llamada ha recibido un número incorrecto de argumentos. "Age: " + 30 mezcla una cadena y un entero. Escribe "Age: " + str(30) o f"Age: {30}". Si area necesita w y h, area(3) también genera TypeError, esta vez porque falta un argumento.

El mensaje distingue estas causas. En can only concatenate str (not "int") to str, Python indica los tipos que se han combinado. Después de age = input("Age: "), age es texto. age + 1 falla; para una entrada que representa un entero, int(age) + 1 realiza una operación aritmética.

Un ValueError significa que se acepta el tipo de la entrada, pero su valor no es adecuado. int("12.5") recibe una cadena, que es un tipo de entrada aceptado, pero el texto no representa un número entero con la forma requerida. math.sqrt(-1) es otro valor inadecuado para un cálculo con números reales.

Comprueba posiciones, claves y atributos

Los divisores cero también provocan fallos con // y %. Buscar una posición inexistente en una lista es distinto de buscar una clave inexistente en un diccionario, aunque ambos casos impliquen solicitar algo que no está.

Detecta un resultado que parece razonable

def total_price(prices):
    total = 0
    for i in range(1, len(prices)):
        total += prices[i]
    return total

Para [4, 6, 10], esto devuelve 16 en lugar de 20. No hay ninguna excepción: los índices 1 y 2 existen, así que todas las operaciones son válidas. El bucle empieza demasiado tarde y omite el índice 0. El error se hace visible al comparar la salida con el total previsto.

Para una excepción que no conozcas, busca su tipo y el mensaje general en la documentación oficial de Python. Elimina de la búsqueda tus propias rutas y valores de entrada; rara vez explican la regla general.

Un error de programación es una diferencia entre el comportamiento previsto y el real. La depuración encuentra la causa y la corrige. Una sesión de depuración útil convierte una observación en una explicación comprobable y después modifica el código basándose en pruebas.

Haz que el fallo se repita

Registra una entrada concreta y el resultado que produce. Para la función de precios que empieza su bucle en el índice 1, usa [4, 6, 10]. El total esperado es 20; el total real es 16. Estos valores concretos permiten comprobar si cada investigación sigue tratando el mismo error.

La diferencia es 4, y el resultado real equivale a 6 + 10. Una hipótesis concreta es que se omite el primer precio. Esa hipótesis predice algo que puedes inspeccionar: el bucle nunca visitará el índice 0.

Sigue seis pasos

1. Reproduce: encuentra una entrada que muestre el error de forma fiable.
2. Indica los resultados esperado y real: calcula el resultado esperado de forma independiente.
3. Formula una hipótesis: indica una causa posible y el comportamiento que predice.
4. Compruébala: inspecciona los valores con llamadas a print, una tabla de seguimiento o un depurador.
5. Corrige la causa: realiza un cambio concreto.
6. Vuelve a probar: ejecuta la entrada que fallaba y los casos que antes funcionaban.

Muestra el índice dentro del bucle. Para esta entrada, los únicos índices son 1 y 2, lo que confirma la predicción. Iniciar range en 0 corrige la omisión del elemento. Recorrer directamente los precios elimina la necesidad de gestionar un índice:

def total_price(prices):
    total = 0
    for price in prices:
        total += price
    return total

La función corregida devuelve 20 para [4, 6, 10], 5 para [5] y 0 para []. El caso de un elemento es útil porque el bucle con el error devolvía antes 0 para él.

Sumar 4 a todas las respuestas corregiría el total observado, pero dejaría la causa. Para [5], ese parche devolvería 4; la cantidad que falta depende de la entrada. Comprueba si una solución propuesta explica todas las pruebas observadas antes de conservarla.

Acota una búsqueda más amplia

Divide y vencerás comprueba los valores que intervienen en el resultado incorrecto en un punto intermedio de la ejecución. Si un valor necesario ya es incorrecto, inspecciona el código anterior que lo ha producido. Si los valores necesarios siguen siendo correctos, sigue su procesamiento posterior. Repite el proceso dentro de la sección restante.

También puedes llamar a una función por separado o eliminar temporalmente código no relacionado. Un ejemplo mínimo reproducible conserva el código más breve y la entrada más pequeña que siguen fallando. Para un problema detectado inicialmente entre cientos de registros, encontrar uno o dos registros que lo desencadenen facilita cada inspección.

Comprueba qué son realmente los datos

Un 5 mostrado puede ser la cadena "5". "5" + "3" produce "53", mientras que la suma numérica da 8. Inspecciona type(value) para comprobar el tipo. Usa repr(value) para revelar espacios y caracteres de salto de línea que una salida normal puede ocultar, como ' Ada'.

Explica el código en voz alta, línea por línea, incluido qué visita realmente cada bucle y qué devuelve cada función. Esto es la depuración con un patito de goma: explicar un paso suele revelar la diferencia entre la operación prevista y la escrita.

Cambia una causa cada vez para poder relacionar el resultado con la modificación. Vuelve a probar tanto los casos que antes funcionaban como el que fallaba.

La respuesta final de un programa oculta el camino que la ha producido. Las llamadas temporales a print, una tabla de seguimiento y un depurador permiten ver ese camino y comprobar una hipótesis concreta sobre dónde falla.

Muestra un valor en un momento conocido

Etiqueta la salida de diagnóstico para que un número tenga un significado claro. Python 3.8 y versiones posteriores admiten esta forma de cadena formateada:

print(f"{i=} {total=}")

Para el bucle de precios con el error, colócala inmediatamente antes de total += prices[i]. Con los precios [4, 6, 10], muestra:

i=1 total=0
i=2 total=6

Estos son los totales antes de cada suma. Después de la primera salida, el bucle suma 6; después de la segunda, suma 10. Una llamada a print después de la suma mostraría totales distintos. Decide qué momento responde a lo que quieres averiguar antes de interpretar la salida.

Sigue el mismo código a mano

Una tabla de seguimiento registra las variables paso a paso. Para este bucle:

No hay ninguna iteración para el índice 0. Sigue los valores reales de inicio y parada escritos en el código, incluso cuando ya sepas qué debería hacer el bucle. Una tabla ayuda a separar lo que esperas de lo que ocurre.

Pausa en un punto de interrupción

Un depurador pausa un programa en ejecución para que puedas inspeccionar su estado actual. Un punto de interrupción marca un lugar donde detenerse. En editores como Thonny y VS Code, haz clic junto a un número de línea e inicia el modo de depuración; en IDLE, haz clic derecho en la línea y elige Establecer punto de interrupción.

Después de pausar, elige un paso según lo que estés investigando:

Si el código que realiza la llamada pasa argumentos correctos, pero recibe una respuesta incorrecta, entra en la función. Si solo necesitas ver el resultado devuelto, ejecuta la llamada como un solo paso. Inspecciona los valores antes y después de la línea que podría crear el error.

Usa el depurador de texto de Python

Inserta breakpoint() justo antes del código que quieras inspeccionar. Con la configuración predeterminada del depurador, ejecutar el programa inicia pdb en ese punto. Escribe estos comandos en su indicador (Pdb):

• p total muestra total.
• n ejecuta la siguiente línea sin entrar en sus llamadas.
• s entra en una llamada a función.
• c continúa la ejecución.
• q sale de la sesión de depuración.

Son comandos del depurador, no líneas para copiar en tu programa.

Distingue la salida mostrada de los resultados devueltos

Una función puede mostrar el número correcto y aun así devolver None porque le falta return total. Inspecciona el valor recibido por el código que realiza la llamada cuando el fallo ocurre después de llamar a la función. Ver una salida correcta dentro de la función no demuestra que el código que la llama haya recibido ese número.

Usa llamadas a print para obtener pistas rápidas a lo largo de las iteraciones de un bucle y el depurador para inspeccionar un momento concreto. Después de corregir el error, elimina las llamadas temporales a print y a breakpoint() para que el programa terminado se ejecute con normalidad.

Una aserción expresa algo que debe ser verdadero si tu código funciona correctamente. Puede detener un error cerca de donde empieza o comparar el resultado de una función con el valor que esperas.

Escribe una condición y un mensaje opcional

assert letter_grade(90) == "A", "90 should be an A"

Python evalúa la condición. Si letter_grade(90) devuelve "A", la condición es verdadera y la ejecución continúa sin salida. Si devuelve "B", Python lanza AssertionError con el mensaje 90 should be an A. La traza señala la comprobación que falla.

Sin el mensaje, assert letter_grade(90) == "A" sigue comprobando el resultado. La última línea de la excepción contiene AssertionError, mientras que la traza muestra la expresión. Un mensaje útil indica la expectativa que no se ha cumplido; debe ayudarte a localizar la regla que se comprueba.

Detén pronto un error interno

Supón que un cálculo interno requiere una lista no vacía:

def average(values):
    assert len(values) > 0, "values must not be empty"
    return sum(values) / len(values)

Una lista vacía activa ahora la aserción antes de la división. La comprobación documenta el supuesto interno de la función y señala directamente su incumplimiento. No da una media a una lista vacía ni decide cómo debe responder una aplicación cuando faltan datos de un usuario.

Mantén activa la validación de datos del usuario

La opción -O de Python elimina las sentencias assert. Por tanto, un programa que dependa de una aserción para rechazar una entrada externa puede comportarse de forma distinta al optimizarse. Comprueba los datos del usuario y otros datos externos con el flujo de control habitual:

def require_score(score):
    if score < 0 or score > 100:
        raise ValueError("score must be 0 to 100")
    return score

Aquí raise ValueError(...) comunica un valor inadecuado. La sentencia if sigue ejecutándose con -O. Elige una aserción para un supuesto interno de programación y una comprobación de entrada activa para datos externos que puedan ser incorrectos.

Evita una comprobación que nunca pueda fallar

assert es una sentencia, no una función. Escribe la condición y el mensaje separados por una coma:

assert x > 10, "x too small"

Escribir assert (x > 10, "x too small") crea una tupla de dos elementos. Una tupla no vacía es verdadera incluso cuando su primer elemento es False, por lo que la aserción se cumple. Python puede avisar de que esta aserción siempre es verdadera. Los paréntesis que rodean solo una condición, como en assert (x > 10), no crean esa tupla; el problema es la coma dentro de los paréntesis.

Usa == para comparar. assert total = 20 es sintaxis no válida porque = asigna un valor.

Compara números con la precisión prevista

Para un número de coma flotante calculado, usa una comprobación de proximidad:

import math

assert math.isclose(0.1 + 0.2, 0.3)

Una comparación exacta falla aquí porque la suma almacenada en coma flotante difiere ligeramente de 0.3. Una prueba automatizada sencilla aplica la misma idea de aserción a una función: assert total_price([4, 6, 10]) == 20. El valor esperado procede de la regla de la función, por lo que la comprobación puede revelar una implementación incorrecta.

Una prueba unitaria comprueba una pequeña unidad de código, normalmente una función, con una entrada elegida y un resultado esperado. Las pruebas automatizadas facilitan repetir las mismas comprobaciones después de editar el código y ayudan a detectar errores que reaparecen en comportamientos que antes funcionaban.

Empieza por la especificación

Supón que una función de calificación debe devolver "A" para puntuaciones de al menos 90, "B" para puntuaciones de al menos 80 pero inferiores a 90, y "C" por debajo de 80. La primera condición, que contiene el error, es score > 90.

Las pruebas deben cumplir varias funciones:

• Los casos típicos comprueban entradas habituales dentro de cada tramo, como 95 y 85.
• Los casos en los límites comprueban los valores donde cambia una regla, como 90 y 89, u 80 y 79.
• Los casos límite comprueban entradas como cero o una colección vacía cuando las reglas de la función las permiten.

Calcula la respuesta esperada a partir de esas reglas. Copiar la respuesta actual del programa en una prueba puede conservar su error.

Coloca las pruebas junto al módulo

Guarda las pruebas en test_grade.py y la función en grade.py. El inicio de la aplicación en grade.py debe estar dentro de su condición de ejecución directa __main__, para que importar la función no inicie el programa.

from grade import letter_grade

def test_letter_grade():
    assert letter_grade(95) == "A"
    assert letter_grade(90) == "A"
    assert letter_grade(85) == "B"

Con la regla que contiene el error, la primera aserción se cumple. La segunda falla porque 90 no es mayor que 90; la ejecución se detiene ahí, antes de la tercera aserción de esta función. Cambiar la primera condición a score >= 90 corrige este límite. Vuelve a ejecutar todas las pruebas para comprobar el caso afectado y el comportamiento anterior.

Asegúrate de que las pruebas se ejecuten realmente

Definir una función de prueba no la llama. Si no usas un ejecutor de pruebas, añade test_letter_grade() al final del archivo de pruebas y después ejecuta python test_grade.py. Para usar pytest, instálalo con python -m pip install pytest y después ejecuta pytest test_grade.py en la terminal. Encuentra las funciones de prueba e informa de sus resultados. Omite las llamadas manuales cuando dejes que un ejecutor las gestione.

Una prueba que solo llama a letter_grade(90) no incluye ninguna comparación. Puede terminar correctamente aunque la respuesta devuelta sea incorrecta; solo falla si la llamada lanza una excepción inesperada. Una aserción conecta la llamada con el comportamiento requerido.

Prueba valores devueltos y propiedades de resultados aleatorios

Una función que solo muestra un total devuelve None. Por tanto, una comparación como assert print_total([4, 6]) == 10 falla aunque la pantalla muestre 10. Haz que el cálculo devuelva su respuesta y deja que main se encargue de mostrarla.

Los resultados aleatorios necesitan una expectativa distinta. No se puede exigir que una función de dado sin semilla devuelva una cara exacta en cada llamada. Comprueba que cada una de 100 llamadas devuelva un valor permitido de 1 a 6, o establece una semilla antes de generar una secuencia reproducible. Superar la prueba de límites comprueba los límites para esas llamadas; no demuestra que todas las caras sean igual de probables.

Cuando aparezca un error nuevo, añade una prueba que falle por ese error antes de corregir la función. Conserva esa prueba de regresión para que las modificaciones posteriores vuelvan a comprobar el mismo comportamiento. Las pruebas que pasan demuestran lo que ha ocurrido en los casos probados; otras entradas aún pueden revelar otro error.

Python incluye unittest, un marco de pruebas que detecta pruebas, las ejecuta e informa de sus resultados por separado. No necesita instalación con pip. Puedes usar su estructura de clases como plantilla mientras aprendes a probar funciones.

Escribe métodos de prueba independientes

Para una función de grade.py, coloca esto en test_grade.py:

import unittest
from grade import letter_grade

class TestLetterGrade(unittest.TestCase):
    def test_top(self):
        self.assertEqual(letter_grade(95), "A")

    def test_boundary(self):
        self.assertEqual(letter_grade(90), "A")

    def test_low(self):
        self.assertEqual(letter_grade(50), "C")

if __name__ == "__main__":
    unittest.main()

TestLetterGrade hereda las herramientas de prueba de unittest.TestCase. Cada prueba es un método cuyo nombre empieza por test. self identifica el objeto de prueba actual; mantenlo en la lista de parámetros de cada método y antes de las llamadas a métodos de aserción. Puedes copiar esta estructura sin diseñar tus propias clases.

De forma predeterminada, las pruebas se ejecutan por orden alfabético de sus nombres de método, así que test_boundary va antes de test_low y test_top. Haz que cada prueba proporcione su propia entrada necesaria y funcione con independencia de las pruebas anteriores.

Elige un método de aserción

Da preferencia a assertEqual(a, b) frente a assertTrue(a == b) al comparar valores: el informe de fallo muestra ambos valores. Los métodos de unittest también mantienen sus comprobaciones cuando Python se ejecuta con -O.

Para comprobar una excepción esperada, encierra la llamada en assertRaises:

def test_score_too_high(self):
    with self.assertRaises(ValueError):
        letter_grade(120)

Esta prueba exige que la regla de la función rechace esa puntuación con ValueError. Un retorno sin excepción hace fallar esta comprobación; una excepción distinta que no sea de aserción se considera un error.

Ejecuta y lee el informe

Ejecuta python test_grade.py para ejecutar su unittest.main() protegido por la condición de ejecución directa. O ejecuta python -m unittest para detectar archivos test*.py en la carpeta actual. python -m unittest -v muestra los nombres de las pruebas y sus resultados individuales.

En el informe breve, . significa que la prueba pasa, F que una aserción ha fallado y E que se ha producido otra excepción. Para una función de calificación con score > 90, las tres pruebas anteriores producen F... El informe de fallo de test_boundary muestra 'B' != 'A': el resultado real es "B", mientras que el esperado es "A". El resumen indica tres pruebas y un fallo.

Antes de editar la función, contrasta la expectativa de la prueba con las reglas de calificación. Una expectativa incorrecta requiere corregir la prueba. Si no se ejecuta ninguna prueba, revisa los nombres de los métodos, la condición de ejecución directa y el comando de inicio. Evita también llamar a tu archivo unittest.py, ya que oculta el módulo estándar.