A continuación, se presenta una versión reestructurada y ampliada de la guía para la Tarea 1 (Hito 1), incorporando todos los elementos necesarios. Esta propuesta está diseñada para ser un documento completo y claro para el desarrollo de la tarea.


Guía Maestra: HITO 1 - Tu Primer Proyecto de Programación Aplicada

Asignatura: Programación de Computadoras con Python Semana 8: 22 - 26 de septiembre de 2025 Segundo Período Académico de 2025

1. Introducción a la Semana del Hito 1

Esta semana es diferente. No introduciremos conceptos teóricos nuevos. En su lugar, nos dedicaremos por completo a nuestro primer gran hito: construir un programa completo, funcional y robusto desde cero. Es el momento de conectar todas las piezas que hemos aprendido (variables, condicionales, bucles, funciones, diccionarios y manejo de errores) para crear una herramienta de ingeniería útil y relevante para tu campo profesional.

El trabajo de esta semana culminará con la entrega de la Tarea 1, un proyecto práctico que demostrará tu capacidad para resolver problemas utilizando la programación.


2. Objetivos de Aprendizaje y Competencias

Al completar exitosamente este proyecto, serás capaz de:

  • Objetivo General: Desarrollar una aplicación de consola interactiva y modular en Python que resuelva un problema específico en el ámbito de la ingeniería (Civil, Agrícola o Agroindustrial), integrando los conceptos fundamentales de la programación.

Competencias Específicas:

  • Análisis y Descomposición de Problemas: Desglosar un problema complejo en sub-problemas más pequeños y manejables, y traducirlos a una estructura de software.
  • Diseño de Software Modular: Estructurar un programa utilizando funciones para encapsular la lógica de negocio, promoviendo la reutilización y la legibilidad del código.
  • Manejo de Estructuras de Datos: Aplicar diccionarios de Python para almacenar y gestionar datos de forma eficiente, como costos, recetas o requerimientos.
  • Programación Robusta: Implementar mecanismos de manejo de errores (try-except) para validar las entradas del usuario y prevenir fallos inesperados en el programa.
  • Desarrollo de Lógica Algorítmica: Utilizar bucles (while) para controlar el flujo de ejecución del programa y mejorar la experiencia del usuario.
  • Colaboración y Comunicación Técnica: Trabajar eficazmente en equipo para desarrollar una solución de software y comunicar los resultados de manera clara y concisa a través de una demostración en video.

3. Estrategias para Alcanzar las Competencias

Para tener éxito en este hito, te recomendamos seguir un proceso de desarrollo estructurado. El rol del docente esta semana es ser un guía y un consultor; el código no se entrega “hecho”, sino que te ayudaremos a construirlo.

  1. Planifica Primero, Programa Después (Fase de Diseño):
    • Antes de escribir código, reúnanse en grupo y dibujen un diagrama de flujo o escriban pseudocódigo.
    • Decidan: ¿Cuál será el menú principal? ¿Qué datos se pedirán y en qué orden? ¿Qué funciones necesitarán? ¿Qué debe hacer cada función (qué recibe y qué devuelve)?
    • Esta planificación es clave para el trabajo en equipo, ya que define las “piezas” que cada miembro puede construir.
  2. Construye en Pequeños Pasos (Desarrollo Incremental):
    • No intenten programar todo de una vez. Dividan el proyecto en metas pequeñas y alcanzables.
    • Paso 1: Creen la estructura básica con el menú principal y el bucle while.
    • Paso 2: Programen la función de cálculo más simple (ej. calcular el volumen).
    • Paso 3: Integren los diccionarios y la función que los utiliza para calcular costos o cantidades.
    • Paso 4: Implementen el manejo de errores con try-except en todas las entradas de usuario.
    • Paso 5: Formateen la salida para que los resultados sean claros y fáciles de leer.
  3. Prueba Constantemente (Aseguramiento de Calidad):
    • Después de implementar cada pequeña parte, ejecuten el código. Prueben con valores esperados, valores límite (como 0) y valores incorrectos (letras, números negativos) para asegurar que todo funcione como se espera.
  4. Usa Nombres Descriptivos (Código Limpio):
    • Nombra bien tus variables y funciones. calcular_costo_total() es mucho más claro que calc(). Un buen nombramiento hace tu código más fácil de leer, depurar y entender por tus compañeros de equipo.

4. Indicaciones para el Trabajo en Grupo (3 a 10 estudiantes)

La colaboración es una habilidad fundamental en el desarrollo de software. Este proyecto está diseñado para ser resuelto en equipo.

Metodología de Trabajo Sugerida:

  1. Reunión de Planificación (Kick-off):
    • Todo el equipo se reúne para elegir una de las tres opciones de proyecto.
    • Discutan la estrategia general y utilicen la “Fase de Diseño” mencionada anteriormente para crear un plan.
    • Asignen roles. Un mismo estudiante puede tener más de un rol si el grupo es pequeño.
  2. Roles Recomendados:
    • Líder de Proyecto (1 estudiante): Coordina al equipo, asegura que todos tengan tareas claras, y es el responsable de integrar el código final.
    • Arquitecto/Diseñador (1-2 estudiantes): Lidera el diseño del programa. Define la estructura de las funciones (qué parámetros reciben y qué retornan) y la estructura de los diccionarios.
    • Desarrolladores (varios estudiantes): Escriben el código de las funciones específicas que les fueron asignadas por el líder y el arquitecto.
    • Tester / QA (1-2 estudiantes): Su misión es “romper” el programa. Prueban el código integrado con todo tipo de entradas (válidas e inválidas) para encontrar errores y reportarlos.
    • Documentador / Encargado del Video (1-2 estudiantes): Escribe los comentarios en el código para explicar su funcionamiento y lidera la creación del guion y la grabación del video de presentación.
  3. Flujo de Desarrollo:
    • El Arquitecto diseña las “firmas” de las funciones (ej. def calcular_volumen(largo, ancho, alto):).
    • El Líder asigna cada función a un Desarrollador.
    • Los Desarrolladores trabajan en sus funciones de forma independiente.
    • El Líder integra todas las funciones en el archivo principal.
    • El Tester prueba la aplicación integrada.
    • El Documentador comenta el código final y prepara la presentación.

5. Opciones de Proyecto (Consignas)

A continuación se presentan las alternativas de proyecto para el Hito 1 (Tarea 1), diseñadas específicamente para los perfiles de Ingeniería Civil, Agrícola y Agroindustrial.

Nota Importante: La estructura de la entrega, los consejos y los recursos de apoyo son los mismos para las tres Ingenierías. El objetivo es el mismo: integrar todos los conceptos del Bloque 1 en una herramienta funcional.

Opción 1: Ingeniería Civil - Calculadora de Costos de Materiales para Cimientos

  • Objetivo: Desarrollar una calculadora en Python que estime la cantidad y el costo de los materiales (cemento, arena, grava, agua) necesarios para construir un cimiento de concreto simple (zapata aislada). El programa debe ser interactivo y fácil de usar.
  • Requisitos Funcionales:
    1. Interfaz de Usuario en Consola: Un menú claro que se ejecute en un bucle, permitiendo al usuario realizar múltiples cálculos o salir.
    2. Entrada de Datos: Solicitar las dimensiones del cimiento: largo (m), ancho (m) y altura (m).
    3. Base de Datos de Costos: Usar un diccionario para almacenar los costos unitarios de los materiales (ej. {'cemento_usd_saco': 8.5, 'arena_usd_m3': 20}).
    4. Cálculos Modulares (Funciones):
      • Una función para calcular el volumen del cimiento.
      • Una función que, a partir del volumen, calcule la cantidad de cada material (usando una dosificación estándar, ej. para 1 m³ de concreto se necesitan 7 sacos de cemento, 0.6 m³ de arena, 0.8 m³ de grava y 0.2 m³ de agua).
      • Una función que calcule el costo total del proyecto.
    5. Robustez: Usar manejo de errores (try-except) para validar todas las entradas numéricas del usuario.
    6. Salida de Resultados: Presentar un resumen claro y bien formateado que incluya el volumen total, la cantidad de cada material requerido y el costo total estimado.

Opción 2: Ingeniería Agrícola - Calculadora de Plan de Fertilización

  • Objetivo: Desarrollar una calculadora que ayude a un agricultor a determinar las necesidades de fertilizantes (N, P, K) y su costo estimado para un cultivo específico en una superficie determinada.
  • Requisitos Funcionales:
    1. Interfaz de Usuario en Consola: Un menú que permita seleccionar un cultivo, ingresar el área y ver los resultados, ejecutándose en un bucle while.
    2. Entrada de Datos: El usuario debe elegir un cultivo de una lista predefinida (ej. Maíz, Tomate, Papa) e ingresar el área a sembrar (en hectáreas).
    3. Base de Datos (Diccionarios):
      • Un diccionario principal con los requerimientos nutricionales (kg/ha) para cada cultivo (ej. {'maiz': {'N': 120, 'P': 60, 'K': 60}, ...}).
      • Otro diccionario con el costo y la composición de los fertilizantes (ej. {'urea': {'costo_usd_saco_50kg': 25, 'aporte_N_porc': 46}, ...}).
    4. Cálculos Modulares (Funciones):
      • Una función que calcule los kg totales necesarios de cada nutriente (N, P, K) según el cultivo y el área.
      • Una función que calcule cuántos sacos de cada fertilizante se necesitan.
      • Una función que calcule el costo total.
    5. Robustez (try-except): Validar que el área ingresada sea un número positivo y manejar otros errores de entrada.
    6. Salida de Resultados: Presentar un resumen que indique: los kg totales de N, P, K, el número de sacos de cada fertilizante y el costo total.

Opción 3: Ingeniería Agroindustrial - Calculadora de Costos para Lote de Producción

  • Objetivo: Desarrollar una herramienta que calcule los costos de materia prima para producir un lote de un producto procesado, como mermelada, néctar o yogur.
  • Requisitos Funcionales:
    1. Interfaz de Usuario en Consola: Un menú principal en un bucle while que permita cotizar diferentes producciones.
    2. Entrada de Datos: El usuario debe seleccionar el producto a fabricar (ej. Mermelada de Fresa, Néctar de Mango) y la cantidad de producto final deseada (en kg).
    3. Base de Datos (Diccionarios):
      • Un diccionario principal con las “recetas” o formulaciones (cuánta materia prima se necesita por cada kg de producto final). Ejemplo: {'mermelada_fresa': {'fruta_kg': 1.1, 'azucar_kg': 0.6, 'pectina_g': 5}}.
      • Otro diccionario con el costo unitario de cada materia prima.
    4. Cálculos Modulares (Funciones):
      • Una función que calcule la cantidad necesaria de cada ingrediente a partir de la receta y la cantidad deseada.
      • Una función que calcule el costo total de la materia prima para el lote.
    5. Robustez (try-except): Validar que la cantidad de producción sea un número positivo.
    6. Salida de Resultados: Mostrar un “desglose de producción” claro que liste la cantidad de cada ingrediente requerido y el costo total estimado.

6. Indicaciones para el Video de Presentación

El video es una parte fundamental de la entrega. Permite demostrar no solo que el programa funciona, sino también que el equipo comprende el código que ha escrito.

  • Duración: 3 a 5 minutos máximo.
  • Formato: Grabación de pantalla (pueden usar Loom, OBS Studio, o la grabadora de Windows/PowerPoint).
  • Participación: Se espera que todos los miembros del equipo hablen en alguna parte del video.

Estructura Sugerida del Video:

  1. Introducción (30 segundos):
    • Presenten a los miembros del equipo.
    • Mencionen qué opción de proyecto eligieron y cuál es su objetivo.
  2. Demostración de Funcionamiento (1-2 minutos):
    • Ejecuten el programa.
    • Realicen un cálculo completo con entradas válidas. Expliquen qué están ingresando y por qué.
    • Muestren el resultado final y verifiquen que es lógico.
  3. Demostración de Robustez (1 minuto):
    • Vuelvan a ejecutar el programa, pero esta vez introduzcan datos incorrectos a propósito (ej. texto donde va un número, un valor negativo, una opción de menú que no existe).
    • Muestren cómo el programa gestiona el error gracias al try-except y pide al usuario que ingrese el dato de nuevo, sin detenerse.
  4. Explicación del Código (1-2 minutos):
    • Muestren brevemente el código fuente. No es necesario explicar línea por línea.
    • Cada miembro puede explicar una parte clave:
      • Uno puede mostrar la estructura del diccionario principal.
      • Otro puede explicar la lógica de la función de cálculo más importante.
      • Otro puede mostrar dónde y por qué se usó el try-except.
  5. Conclusión (30 segundos):
    • Resuman brevemente el resultado del proyecto, mencionen qué fue lo más desafiante o lo más interesante que aprendieron.

7. Checklist de Entrega y Recursos

Checklist de Entrega:

  • Código Fuente: Un único archivo .py o un enlace a un Google Colab Notebook con el código completo del proyecto.
  • Comentarios en el Código: El código debe estar comentado, explicando las partes más importantes, especialmente la lógica de las funciones y la estructura de los diccionarios.
  • Video Demostración: El enlace al video (subido a YouTube, Drive, o similar) donde el equipo presenta el proyecto siguiendo la estructura indicada.

💡 Prompts Sugeridos para IA (Como Herramienta de Apoyo):

  • Planificación: “Estoy empezando un proyecto en Python para una calculadora de [costos de cimientos / fertilización / producción]. ¿Cómo puedo descomponer este problema en funciones? Dame una estructura de funciones sugerida con sus parámetros y lo que deberían retornar.”
  • Depuración: “Mi programa me da un error: [pegar el error]. Este es el bloque de código que lo causa: [pegar el código]. ¿Puedes explicarme qué significa este error y dónde podría estar el problema?”
  • Lógica de Código: “Tengo un diccionario con precios, precios = {'cemento': 8, 'arena': 20}, y otro con cantidades, cantidades = {'cemento': 14, 'arena': 1.2}. ¿Cómo puedo escribir un bucle en Python para calcular el costo total multiplicando las cantidades por sus precios?”
  • Refactorización: “Este es el código de mi función [pegar función]. Funciona, pero se ve muy largo y repetitivo. ¿Puedes darme sugerencias para hacerlo más corto, eficiente y legible?”

8. Rúbrica de Evaluación del Hito 1

Puntaje Total: 100 Puntos

Criterio de Evaluación Sobresaliente (90-100%) Notable (75-89%) Aprobado (60-74%) Insuficiente (<60%) Ponderación
Correctitud Funcional El programa calcula todos los valores de forma precisa y sin errores lógicos. La salida es correcta para todos los casos de prueba. El programa calcula correctamente la mayoría de los valores, pero puede tener un error lógico menor en un caso específico. El programa realiza los cálculos básicos, pero presenta errores significativos en la lógica o en los resultados finales. El programa no se ejecuta, se detiene inesperadamente o los cálculos son fundamentalmente incorrectos. 30%
Estructura y Modularidad El código está excelentemente organizado en funciones claras y cohesivas. Cada función tiene una única responsabilidad bien definida. El código utiliza funciones, pero algunas podrían estar mejor definidas o son demasiado largas. La modularidad es buena pero mejorable. El código usa funciones, pero de manera desorganizada. Hay lógica de negocio fuera de las funciones o funciones que hacen demasiadas cosas. El código no utiliza funciones o su uso es mínimo y no aporta a la estructura. La mayor parte del código está en el script principal. 20%
Uso de Diccionarios Los diccionarios están bien estructurados y se utilizan de manera eficiente para gestionar todos los datos requeridos (costos, recetas, etc.). Se utilizan diccionarios para gestionar los datos, pero su estructura podría ser más óptima o su implementación ligeramente ineficiente. Se utilizan diccionarios, pero de forma parcial o incorrecta. Parte de los datos está “hardcodeada” en el código en lugar de en la estructura de datos. No se utilizan diccionarios o su uso es incorrecto, impidiendo el funcionamiento adecuado del programa. 15%
Robustez y Manejo de Errores El programa implementa try-except de forma exhaustiva, controlando todas las entradas del usuario y mostrando mensajes de error claros sin detenerse. El programa maneja los errores de entrada más comunes, pero puede fallar con algún caso no previsto. El programa intenta manejar errores, pero la implementación es incompleta y el programa puede detenerse con ciertas entradas inválidas. El programa no tiene manejo de errores y se detiene abruptamente al ingresar datos incorrectos. 15%
Calidad del Código y Comentarios El código es muy legible, con nombres de variables y funciones descriptivos. Los comentarios son claros, concisos y explican el “porqué” de la lógica. El código es legible y está comentado, aunque los nombres o los comentarios podrían ser más claros en algunas secciones. El código es funcional pero difícil de leer. Los comentarios son escasos, ausentes o no aportan valor. El código es desordenado, confuso y no está comentado, lo que lo hace muy difícil de entender. 10%
Video y Trabajo en Equipo El video es claro, conciso y sigue la estructura propuesta. Todos los miembros participan y demuestran un profundo entendimiento del proyecto. El video es bueno y cumple con los requisitos. La participación del equipo es evidente, aunque la explicación podría ser más fluida. El video demuestra que el programa funciona, pero es desorganizado o no todos los miembros participan. La explicación del código es superficial. No se entrega el video, o el video no demuestra el funcionamiento del programa ni la comprensión del equipo sobre el código. 10%