Módulo 5: Fechas, cálculos y simulaciones confiables

Muchos errores de software no aparecen porque el programa desconozca una fórmula. Aparecen porque utiliza la herramienta incorrecta:

"15/08/2026" se compara como texto
              ↓
el orden puede ser incorrecto

0.1 + 0.2 se calcula con float
              ↓
0.30000000000000004

una selección aleatoria cambia en cada prueba
              ↓
el error no puede reproducirse

Python incluye módulos especializados para resolver estos problemas sin reinventar calendarios, fórmulas estadísticas, generadores pseudoaleatorios ni aritmética monetaria.

En este módulo aprenderás a escoger entre:

• datetime para fechas, horas y duraciones;
• math para cálculos matemáticos concretos;
• statistics para describir colecciones numéricas;
• random para muestras y simulaciones reproducibles;
• Decimal para cálculos decimales que exigen exactitud controlada.

Principio del módulo: un cálculo confiable comienza al representar correctamente el dato.

Al completar el módulo serás capaz de:

• Diferenciar date, time, datetime y timedelta.
• Crear, comparar y modificar fechas sin operar manualmente con días o meses.
• Interpretar texto con strptime() y presentar fechas con strftime().
• Calcular vencimientos, antigüedades y duraciones.
• Reconocer la diferencia entre objetos temporales con y sin zona horaria.
• Utilizar zoneinfo únicamente cuando el problema requiere zonas horarias reales.
• Elegir entre operadores, funciones integradas y el módulo math.
• Aplicar ceil(), floor(), sqrt() e isclose() en situaciones concretas.
• Calcular media, mediana, moda y dispersión con statistics.
• Distinguir una población completa de una muestra.
• Seleccionar datos con y sin reemplazo mediante random.
• Reproducir una simulación mediante una semilla controlada.
• Reconocer cuándo debe utilizarse secrets en lugar de random.
• Explicar por qué algunos decimales no se representan exactamente con float.
• Construir valores Decimal correctamente a partir de texto.
• Aplicar una política explícita de redondeo con quantize().
• Crear un reporte que combine vencimientos, métricas, muestras y dinero.

Necesitas poder:

• crear funciones y recorrer colecciones;
• trabajar con diccionarios;
• convertir texto a int y float;
• ordenar mediante key;
• utilizar comprensiones;
• capturar errores específicos básicos;
• importar módulos de la biblioteca estándar;
• leer archivos de datos sencillos si decides ampliar el proyecto.

No se enseñará nuevamente la lógica de condicionales, ciclos o funciones. El objetivo es utilizar herramientas especializadas sobre problemas reales.

Desarrollarás un Planificador de vencimientos y reporte de métricas. El programa recibirá tareas con fecha límite, duración, prioridad y costo estimado.

Tareas recibidas
      │
      ├─ interpretar fechas
      ├─ validar duración y costo
      ├─ calcular días restantes
      ├─ clasificar vencimientos
      ├─ resumir duraciones
      ├─ calcular costos exactos
      └─ elegir muestra reproducible
               ↓
        Reporte profesional

El reporte responderá preguntas útiles:

• ¿Qué tareas están vencidas?
• ¿Cuáles vencen durante los próximos siete días?
• ¿Cuántas sesiones de trabajo requiere cada tarea?
• ¿Cuál es la duración media y mediana?
• ¿Qué tan dispersas son las estimaciones?
• ¿Cuál es el subtotal, el impuesto y el total?
• ¿Qué tareas forman la muestra de revisión?
• ¿Puede otra persona obtener exactamente la misma muestra?

Los retos opcionales requieren tiempo adicional.

Fechas, horas y duraciones con datetime

El módulo se llama datetime, pero contiene varios tipos:

from datetime import date, datetime, time, timedelta


fecha_limite = date(2026, 8, 22)
hora_apertura = time(8, 30)
momento_revision = datetime(2026, 8, 15, 14, 45)
duracion = timedelta(days=7, hours=2)

print(fecha_limite)
print(hora_apertura)
print(momento_revision)
print(duracion)

No utilices una cadena cuando el programa necesita comparar, ordenar o calcular fechas. El texto "2026-08-22" describe una fecha para una persona; un objeto date permite trabajar con ella.

from datetime import date


inicio = date(2026, 8, 15)
fin = date(2026, 8, 22)

print(inicio.year)      # 2026
print(inicio.month)     # 8
print(inicio.day)       # 15
print(inicio.weekday()) # 5: sábado

weekday() utiliza el rango de 0 a 6:

0 lunes
1 martes
2 miércoles
3 jueves
4 viernes
5 sábado
6 domingo

Python valida el calendario:

from datetime import date


fecha_imposible = date(2026, 2, 30)  # ValueError

No necesitas escribir reglas manuales para recordar cuántos días tiene febrero.

from datetime import date, datetime


hoy = date.today()
ahora_local = datetime.now()

• Usa date.today() si solo importa el día.
• Usa datetime.now() si también importa la hora local.
• No obtengas datetime.now() para después ignorar la hora si date.today() expresa mejor la intención.

En programas que deben probarse, conviene recibir la fecha de referencia como argumento:

from datetime import date


def dias_hasta(fecha_limite, referencia=None):
    if referencia is None:
        referencia = date.today()

    return (fecha_limite - referencia).days


referencia_prueba = date(2026, 8, 15)
limite = date(2026, 8, 22)

print(dias_hasta(limite, referencia_prueba))  # 7

Esta función puede utilizar la fecha real en producción y una fecha fija durante las pruebas.

Los objetos del mismo tipo pueden compararse directamente:

from datetime import date


hoy = date(2026, 8, 15)
limite = date(2026, 8, 12)

if limite < hoy:
    print("La tarea está vencida.")
elif limite == hoy:
    print("La tarea vence hoy.")
else:
    print("La tarea continúa vigente.")

Evita comparar cadenas con formatos distintos:

"30/01/2026" < "02/02/2026"  # compara caracteres, no fechas

Restar fechas produce una duración:

from datetime import date, timedelta


inicio = date(2026, 8, 15)
limite = date(2026, 8, 22)

diferencia = limite - inicio
print(diferencia)       # 7 days, 0:00:00
print(diferencia.days)  # 7

nueva_fecha = inicio + timedelta(days=30)
print(nueva_fecha)      # 2026-09-14

timedelta(days=30) significa exactamente treinta días. No significa “un mes calendario”. Los meses tienen longitudes distintas y la biblioteca estándar no incluye una duración llamada “un mes”.

Error común: utilizar .seconds como duración total

from datetime import timedelta


duracion = timedelta(days=2, seconds=3600)

print(duracion.seconds)          # 3600
print(duracion.total_seconds())  # 176400.0

.seconds contiene solo la parte de segundos restante dentro del día. Para convertir la duración completa, utiliza total_seconds().

Los datos externos suelen llegar como texto:

from datetime import datetime


texto = "22/08/2026"
fecha = datetime.strptime(texto, "%d/%m/%Y").date()

print(fecha)        # 2026-08-22
print(type(fecha))  # <class 'datetime.date'>

Directivas frecuentes:

El patrón debe describir exactamente el texto:

from datetime import datetime


formatos = {
    "2026-08-22": "%Y-%m-%d",
    "22/08/2026": "%d/%m/%Y",
    "22-08-2026 14:30": "%d-%m-%Y %H:%M",
}

for texto, formato in formatos.items():
    valor = datetime.strptime(texto, formato)
    print(valor)

Una fecha imposible o un formato distinto producen ValueError. Captura ese error cerca del límite donde entra el dato:

from datetime import datetime


def interpretar_fecha(texto, formato="%Y-%m-%d"):
    try:
        return datetime.strptime(texto, formato).date()
    except ValueError:
        return None

En un programa profesional conviene conservar también el texto original y explicar por qué fue rechazado.

from datetime import date


fecha = date(2026, 8, 22)

print(fecha.strftime("%Y-%m-%d"))  # 2026-08-22
print(fecha.strftime("%d/%m/%Y"))  # 22/08/2026

La dirección de las operaciones puede recordarse así:

texto  ── strptime() ──> datetime
fecha  ── strftime() ──> string

strptime() interpreta; strftime() formatea.

Para almacenar e intercambiar fechas simples, el formato ISO AAAA-MM-DD es una excelente opción porque es inequívoco y se ordena correctamente como texto cuando todas las fechas siguen el mismo formato.

Cuando el texto ya utiliza un formato ISO compatible, no necesitas escribir el patrón:

from datetime import date, datetime


fecha = date.fromisoformat("2026-08-22")
momento = datetime.fromisoformat("2026-08-22T14:30:00")

print(fecha.isoformat())
print(momento.isoformat())

Utiliza:

• fromisoformat() cuando el contrato de entrada exige ISO;
• strptime() cuando debes interpretar otro formato conocido;
• nunca “adivines” formatos ambiguos sin una regla definida.

Los objetos temporales son inmutables. replace() devuelve otro objeto:

from datetime import date


original = date(2026, 8, 22)
corregida = original.replace(day=25)

print(original)   # 2026-08-22
print(corregida)  # 2026-08-25

No utilices replace(month=mes + 1) para sumar un mes: diciembre, las distintas longitudes de los meses y los días inexistentes requieren reglas de negocio que replace() no inventará por ti.

Un datetime sin zona horaria es ingenuo (naive):

from datetime import datetime


momento = datetime(2026, 8, 15, 9, 0)
print(momento.tzinfo)  # None

Un datetime consciente (aware) conoce su zona o desplazamiento:

from datetime import datetime
from zoneinfo import ZoneInfo


costa_rica = ZoneInfo("America/Costa_Rica")
momento = datetime(2026, 8, 15, 9, 0, tzinfo=costa_rica)

print(momento.isoformat())

Utiliza zonas horarias cuando el significado del problema lo exige, por ejemplo:

• reuniones entre países;
• registros de eventos distribuidos;
• fechas de publicación global;
• vencimientos definidos para una zona específica.

Si una tarea vence por día y no por una hora exacta, un objeto date suele ser suficiente y más claro.

No compares un datetime ingenuo con uno consciente. Define primero qué representa cada valor y normaliza la estrategia temporal de la aplicación.

Cálculos útiles con math

Python ofrece tres niveles habituales:

No importes math para calcular cantidad * precio. Sí utilízalo cuando la operación tiene un nombre y una implementación estándar.

import math


horas = 7.2
capacidad_por_sesion = 2.5

sesiones_necesarias = math.ceil(horas / capacidad_por_sesion)
sesiones_completas = math.floor(horas / capacidad_por_sesion)

print(sesiones_necesarias)  # 3
print(sesiones_completas)   # 2

• ceil(x) redondea hacia arriba.
• floor(x) redondea hacia abajo.

No sustituyas estas reglas con round(). Redondear al valor más cercano no responde la pregunta “¿cuántas cajas necesito para guardar todos los objetos?”.

import math


area = 81
lado = math.sqrt(area)
diagonal = math.hypot(3, 4)

print(lado)      # 9.0
print(diagonal)  # 5.0

hypot() expresa directamente el cálculo de una distancia euclidiana y puede ser más claro que reconstruir manualmente la fórmula.

resultado = 0.1 + 0.2
print(resultado == 0.3)  # False

Para comprobar resultados aproximados de punto flotante:

import math


print(math.isclose(0.1 + 0.2, 0.3))  # True

Puedes controlar tolerancias:

math.isclose(valor_obtenido, valor_esperado, rel_tol=1e-9, abs_tol=1e-12)

• rel_tol compara el error en relación con el tamaño de los valores.
• abs_tol establece un margen absoluto, especialmente útil cerca de cero.

isclose() no convierte un cálculo monetario inexacto en exacto. Para dinero se utilizará Decimal.

import math


print(math.pi)
print(math.e)
print(math.gcd(24, 36))
print(math.lcm(6, 8))
print(math.fsum([0.1] * 10))

No necesitas memorizar todo el módulo. Aprende a reconocer que la herramienta existe y consulta la documentación cuando el problema lo requiera.

Estadística descriptiva con statistics

El módulo statistics resume una colección mediante medidas conocidas. No sustituye el análisis del contexto.

from statistics import mean, median, multimode


duraciones = [2, 2.5, 3, 4, 8]

print(mean(duraciones))       # 3.9
print(median(duraciones))     # 3
print(multimode(duraciones))  # [2, 2.5, 3, 4, 8]

En esta colección todos los valores aparecen una sola vez; por eso multimode() devuelve todos. No siempre existe una moda útil.

from statistics import mean, median


duraciones = [2, 2, 3, 3, 20]

print(mean(duraciones))    # 6
print(median(duraciones))  # 3

La tarea de 20 horas eleva la media. La mediana permanece cerca del centro de la mayoría de observaciones.

• Media: utiliza todos los valores; es sensible a extremos.
• Mediana: representa el centro después de ordenar; resiste mejor valores extremos.

No elijas una medida solo porque su función es fácil de llamar. Explica cuál describe mejor el problema.

from statistics import mode, multimode


prioridades = ["alta", "media", "alta", "media", "baja"]

print(mode(prioridades))       # alta: la primera entre las empatadas
print(multimode(prioridades))  # ['alta', 'media']

Cuando un empate importa, multimode() evita ocultarlo.

Estas colecciones tienen la misma media:

A = [4, 4, 4, 4, 4]
B = [1, 2, 4, 6, 7]

Sin embargo, B está mucho más dispersa. La desviación estándar resume cuánto tienden a alejarse los valores del centro.

from statistics import pstdev, stdev


datos = [1, 2, 4, 6, 7]

print(pstdev(datos))  # desviación de una población completa
print(stdev(datos))   # estimación a partir de una muestra

Utiliza:

• pstdev() cuando los datos representan toda la población que deseas describir;
• stdev() cuando los datos son una muestra usada para estimar una población mayor.

En el proyecto se analizarán todas las tareas aceptadas del conjunto recibido, por lo que se utilizará pstdev().

from statistics import StatisticsError, mean, stdev


try:
    print(mean([]))
except StatisticsError:
    print("No hay datos para calcular la media.")

try:
    print(stdev([5]))
except StatisticsError:
    print("Se necesitan al menos dos observaciones.")

Valida el tamaño antes de calcular. Un reporte debe decir “sin datos suficientes”, no inventar un cero estadístico.

Aleatoriedad reproducible con random

random genera valores mediante un algoritmo determinista cuyo estado inicial puede controlarse. Es adecuado para:

• simulaciones;
• juegos no relacionados con dinero real;
• selección de casos de prueba;
• muestras educativas;
• datos ficticios.

No es adecuado para contraseñas, enlaces de recuperación, tokens o claves. Para seguridad utiliza secrets.

import random


opciones = ["alta", "media", "baja"]

print(random.randint(1, 6))
print(random.choice(opciones))
print(random.choices(opciones, weights=[2, 5, 3], k=4))
print(random.sample(opciones, k=2))

sample() produce un error si k supera el tamaño de la población. Valida el tamaño o limita la muestra de forma explícita.

import random


original = ["A", "B", "C", "D"]
copia = original.copy()

random.shuffle(copia)

print(original)  # conserva el orden
print(copia)     # orden mezclado

shuffle() trabaja en el lugar y devuelve None. Si necesitas conservar el orden inicial, mezcla una copia.

import random


random.seed(42)
print(random.sample(range(1, 11), k=3))

La misma semilla permite reproducir la secuencia dentro de condiciones equivalentes. Esto ayuda a:

• repetir un error;
• comparar dos implementaciones;
• comprobar resultados educativos;
• documentar una simulación.

Sin embargo, random.seed() cambia el generador global del módulo. En una función o aplicación compartida, una instancia independiente suele ser más segura:

import random


generador = random.Random(42)
muestra = generador.sample(range(1, 11), k=3)

El proyecto utilizará random.Random(semilla) para no alterar otras operaciones aleatorias del programa.

Una semilla conocida permite reconstruir la secuencia. Para crear un token:

import secrets


token = secrets.token_urlsafe(24)
print(token)

No se profundizará en criptografía. La decisión importante es clara:

simulación, juego o muestra  → random
contraseña, token o seguridad → secrets

Precisión decimal

Muchos valores decimales no tienen una representación binaria finita:

print(0.1 + 0.2)
print((0.1 + 0.2) == 0.3)

Resultado:

0.30000000000000004
False

Para mediciones aproximadas, gráficos o cálculos científicos, float suele ser apropiado y math.isclose() permite comparar tolerancias. Para dinero y otras reglas decimales exactas, utiliza Decimal.

from decimal import Decimal


precio = Decimal("0.10")
impuesto = Decimal("0.20")

print(precio + impuesto)  # 0.30

Evita construirlo desde un float ya aproximado:

from decimal import Decimal


incorrecto = Decimal(0.1)
correcto = Decimal("0.1")

print(incorrecto)
print(correcto)

Si el dato externo llega como texto, pásalo directamente a Decimal después de validarlo.

Si ya tienes un entero, es seguro construir desde él:

cantidad = Decimal(3)

from decimal import Decimal


precio = Decimal("10.50")

total = precio * 1.13 # TypeError

total = precio * Decimal("1.13")

Mantén toda la cadena monetaria en `Decimal`: valores, tasas, subtotales, impuestos y totales.

## 5.4. Redondear con una política explícita

`quantize()` ajusta el número de posiciones decimales:

from decimal import Decimal, ROUND_HALF_UP

CENTAVO = Decimal("0.01") valor = Decimal("10.125") redondeado = valor.quantize(CENTAVO, rounding=ROUND_HALF_UP)

print(redondeado) # 10.13

La política de redondeo pertenece al problema. `ROUND_HALF_UP` es frecuente en ejemplos comerciales, pero una organización puede exigir otra regla. No la elijas silenciosamente.

## 5.5. Ejemplo monetario completo

from decimal import Decimal, ROUND_HALF_UP

CENTAVO = Decimal("0.01") TASA_IMPUESTO = Decimal("0.13")

costos = [Decimal("18.50"), Decimal("25.00"), Decimal("42.75")] subtotal = sum(costos, start=Decimal("0.00")) impuesto = (subtotal * TASA_IMPUESTO).quantize( CENTAVO, rounding=ROUND_HALF_UP, ) total = subtotal + impuesto

print(f"Subtotal: ₡{subtotal:,.2f}") print(f"Impuesto: ₡{impuesto:,.2f}") print(f"Total: ₡{total:,.2f}")

Se redondea el impuesto después de calcularlo sobre el subtotal. Si una regla exige redondear el impuesto de cada línea por separado, el resultado podría cambiar. Documenta siempre el momento del redondeo.

## 5.6. Validar entradas decimales

from decimal import Decimal, InvalidOperation

def convertir_decimal(texto): try: valor = Decimal(texto.strip()) except InvalidOperation: return None

if not valor.is_finite(): return None

return valor

`Decimal` también reconoce valores especiales como `NaN` e `Infinity`. En un costo normal deben rechazarse mediante `is_finite()`.

> El texto `"48,90"` no utiliza el punto esperado por `Decimal`. Decide si el contrato lo rechaza o si existe una normalización autorizada; no reemplaces toda coma sin conocer el formato de entrada.

---

Videos recomendados

Los videos complementan los ejemplos. La documentación oficial continúa siendo la referencia principal para firmas, límites y comportamiento actual.

Explica fecha y hora actual, componentes, formato y conversión mediante strptime(). Relaciona sus ejemplos con la clasificación de vencimientos del proyecto.

Utilízalo para reforzar la selección de las medidas centrales. El proyecto añade dispersión, empates y validación de colecciones.

Repasa la generación y selección aleatoria. Para reproducibilidad, muestras sin reemplazo y advertencias de seguridad, conserva como guía las secciones de este módulo y la documentación oficial.

El título es provocativo, pero el contenido ilustra el problema de la representación binaria y presenta Decimal como solución para cálculos monetarios. Python sí puede utilizarse profesionalmente en sistemas financieros cuando se eligen tipos, reglas y controles adecuados.

Documentación y recursos de lectura

• 📖`datetime`: tipos básicos de fecha y hora
• 📖`zoneinfo`: soporte de zonas horarias de IANA
• 📖`math`: funciones matemáticas
• 📖`statistics`: estadística matemática
• 📖`random`: números pseudoaleatorios
• 📖`secrets`: números aleatorios para seguridad
• 📖`decimal`: aritmética decimal
• 📖Tutorial: problemas y limitaciones del punto flotante

Nivel esencial

1. Revisa las clases disponibles en datetime.
2. Consulta las directivas de strftime() y strptime().
3. Compara sample() con choices().
4. Revisa los ejemplos de Decimal y quantize().

Nivel de profundización

1. Lee la diferencia documentada entre objetos temporales ingenuos y conscientes.
2. Compara stdev() con pstdev().
3. Revisa las notas de reproducibilidad de random.
4. Consulta los modos de redondeo de decimal.

Preguntas que debes hacer al leer documentación

• ¿Qué tipos recibe la función?
• ¿Qué tipo devuelve?
• ¿Los límites están incluidos?
• ¿Modifica el objeto recibido?
• ¿Qué excepciones puede producir?
• ¿Trabaja con una muestra o una población?
• ¿La operación es exacta o aproximada?
• ¿Existe una advertencia de seguridad?

Material descargable

El módulo incluye:

• datos_tareas.py con doce tareas de control;
• plantilla_proyecto.py con la arquitectura recomendada;
• GUIA_SELECCION_NUMERICA.md para elegir tipos y módulos;
• CASOS_PRUEBA.md con los resultados que debes demostrar;
• CHECKLIST_PROYECTO.md para revisar la entrega;
• un paquete ZIP con todos los materiales.

Trabaja primero con los valores de referencia. Cuando el proyecto esté aprobado, puedes permitir que el usuario elija otra fecha y otra semilla.

⬇️Descargar todos los materiales del Módulo 5

Errores comunes y cómo corregirlos

Glosario

Fecha de referencia: día respecto al cual se calculan vencimientos o diferencias.

`date`: tipo que representa una fecha sin hora.

`time`: tipo que representa una hora sin una fecha asociada.

`datetime`: tipo que combina fecha y hora.

`timedelta`: duración o diferencia entre valores temporales.

Formato ISO: representación estandarizada; para una fecha simple se usa habitualmente AAAA-MM-DD.

`strptime()`: operación que interpreta una cadena según un formato temporal.

`strftime()`: operación que presenta un objeto temporal como cadena.

Objeto ingenuo: datetime sin información de zona horaria.

Objeto consciente: datetime con información de zona o desplazamiento.

Tolerancia: margen permitido al comparar resultados aproximados.

Media: suma de los valores dividida entre su cantidad.

Mediana: valor central de una colección ordenada.

Moda: valor o valores con mayor frecuencia.

Dispersión: grado en que los valores se separan entre sí o respecto al centro.

Población: conjunto completo que se desea describir.

Muestra: subconjunto utilizado para estudiar una población mayor.

Pseudoaleatorio: resultado producido por un algoritmo que parece aleatorio, pero depende de su estado.

Semilla: valor utilizado para inicializar un generador pseudoaleatorio.

Muestreo sin reemplazo: selección en la que un elemento no puede aparecer dos veces en la misma muestra.

Punto flotante: representación binaria aproximada utilizada por float.

`Decimal`: tipo de aritmética decimal con precisión y redondeo controlables.

Cuantización: ajuste de un decimal a un exponente o número de posiciones determinado.

Política de redondeo: regla explícita para resolver los dígitos que no se conservarán.

Resumen final

En este módulo aprendiste que el tipo de dato forma parte de la solución. Una fecha no es únicamente texto, una duración no es una resta manual, una muestra aleatoria no es necesariamente irrepetible y un importe no debería depender de aproximaciones binarias ocultas.

Ahora puedes:

• interpretar, presentar, comparar y modificar fechas;
• calcular vencimientos mediante timedelta;
• diseñar funciones temporales que admiten pruebas controladas;
• reconocer cuándo una zona horaria aporta valor real;
• reservar recursos mediante ceil();
• comparar aproximaciones mediante isclose();
• describir datos con media, mediana, moda y dispersión;
• distinguir población y muestra;
• seleccionar elementos con o sin reemplazo;
• reproducir simulaciones con un generador local;
• elegir secrets para valores sensibles;
• construir importes con Decimal desde texto;
• aplicar y documentar una política de redondeo;
• integrar fechas, métricas, muestras y costos en un reporte profesional.

• Completé las cinco prácticas guiadas.
• Entregué las seis actividades obligatorias.
• Puedo explicar date, datetime y timedelta.
• Distingo strptime() de strftime().
• Probé los límites temporales -1, 0, 1, 7 y 8.
• Sé por qué round() no sustituye a ceil().
• Distingo stdev() de pstdev().
• Puedo obtener todas las modas de un empate.
• Distingo choice(), choices() y sample().
• La misma semilla y el mismo orden producen la muestra de control.
• Utilizo secrets para valores sensibles.
• No construyo dinero desde float.
• Documenté la política y el momento del redondeo.
• Obtuve 8 tareas aceptadas y 4 rechazadas.
• Obtuve subtotal 836.04, impuesto 108.69 y total 944.73.
• Documenté las doce pruebas del proyecto.
• Obtuve al menos 8 de 10 en la evaluación.
• El proyecto fue aprobado.

Cuando todos los puntos estén completos, estarás preparado para continuar con el Módulo 6 de Python Práctico.