100 Días de Código en Python — Día 15: Entorno de Desarrollo Local y la Máquina de Café

🎯 Objetivo de aprendizaje#

• Instalar Python y un editor de código.
• Crear un proyecto con un archivo main.py y ejecutarlo.

📖 Explicación conceptual#

Pasos generales:

1. Instala Python desde python.org. En Windows, marca la casilla "Add python.exe to PATH" durante la instalación.
2. Instala PyCharm (la edición gratuita es suficiente para el curso).
3. Crea un proyecto nuevo, por ejemplo CoffeeMachine, y verifica que el intérprete sea la última versión de Python instalada.
4. Clic derecho en la carpeta del proyecto → New → Python File → main.py.
5. Escribe print("¡Hola desde mi computador!") y ejecútalo con el botón ▶️ o clic derecho → Run 'main'. El resultado aparece en la consola de la parte inferior.

Alternativa válida: VS Code con la extensión de Python. El curso usa PyCharm, así que las indicaciones de este y los siguientes días hacen referencia a sus menús.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: crea 3 comentarios TODO en distintos lugares de un archivo y navega entre ellos con la pestaña TODO.
• 🟡 Reto 2: usa la edición multicursor para convertir 5 líneas de texto en 5 print("...").
• 🟠 Reto 3: escribe una función con docstring y comprueba que PyCharm lo muestra al pasar el ratón sobre la llamada.
• 🔴 Reto 4: escribe a propósito una línea de más de 79 caracteres y divídela correctamente usando paréntesis. Investiga en PEP 8 cómo se recomienda hacerlo.

📖 Los datos del problema#

Tres bebidas calientes, cada una con su receta y su precio. En el código inicial vienen en un diccionario anidado MENU. Estos son valores de referencia coherentes con las lecciones (el latte gasta 200 ml de agua):

MENU = {
    "espresso": {
        "ingredients": {"water": 50, "coffee": 18},
        "cost": 1.5,
    },
    "latte": {
        "ingredients": {"water": 200, "milk": 150, "coffee": 24},
        "cost": 2.5,
    },
    "cappuccino": {
        "ingredients": {"water": 250, "milk": 100, "coffee": 24},
        "cost": 3.0,
    },
}

resources = {
    "water": 300,    # ml
    "milk": 200,     # ml
    "coffee": 100,   # g
}

Monedas de EE. UU. que acepta la máquina:

El curso comenta que la moneda de 5 centavos (nickel) es más grande que la de 10 (dime), algo que confunde a quien no es de EE. UU. "Una lección de diseño": el tamaño no siempre indica el valor.

📝 Ejercicio original del curso: requisitos del programa#

Advertencia del curso: es un proyecto ambicioso. Dedícale al menos una hora antes de ver la solución, y compara tu programa con el comportamiento de la versión final.

🔍 Antes de programar#

• ¿Qué datos cambian mientras la máquina funciona? ¿Dónde los guardarás?
• ¿Qué tareas se pueden convertir en funciones? ¿Qué recibe y qué devuelve cada una?
• ¿En qué orden deben ocurrir las comprobaciones? ¿Tiene sentido pedir el dinero antes de saber si hay ingredientes?
• Escribe los 7 requisitos como comentarios # TODO en tu main.py.

Contexto#

Programar algo que existe en la vida real obliga a pensar en todos los casos: qué pasa si no hay leche, si el cliente paga de menos, si el técnico necesita apagarla.

Restricciones técnicas#

Funciones con docstring, diccionarios anidados, un bucle while controlado por una variable y el manejo de una variable global.

Construcción paso a paso (siguiendo la solución del curso)#

Versión 1 — El bucle principal y el apagado (requisitos 1 y 2). El curso empieza con while True: y descubre que el programa pregunta "hasta la eternidad". La solución es una variable de control:

is_on = True

while is_on:
    choice = input("What would you like? (espresso/latte/cappuccino): ")
    if choice == "off":
        is_on = False

Versión 2 — El informe (requisito 3). Se crea profit = 0 (la alcancía empieza vacía) y un elif choice == "report": con cuatro print. El curso usa la edición multicursor para escribir los print y los convierte en f-strings:

    elif choice == "report":
        print(f"Water: {resources['water']}ml")
        print(f"Milk: {resources['milk']}ml")
        print(f"Coffee: {resources['coffee']}g")
        print(f"Money: ${profit}")

Detalle de comillas: dentro de un f-string con comillas dobles, la clave del diccionario va entre comillas simples ('water').

Versión 3 — ¿Hay recursos? (requisito 4). En el else, drink = MENU[choice] obtiene el diccionario de la bebida. Como es una tarea con un objetivo claro, el curso la convierte en función:

def is_resource_sufficient(order_ingredients):
    """Devuelve True cuando se puede preparar el pedido y False si los ingredientes no alcanzan."""
    for item in order_ingredients:
        if order_ingredients[item] >= resources[item]:
            print(f"Sorry there is not enough {item}.")
            return False
    return True

El curso ofrece una alternativa igual de válida si el doble return confunde: una variable is_enough = True que cambia a False dentro del if y se devuelve al final.

🛠️ Nota técnica (verificada): la condición >= rechaza el pedido cuando la máquina tiene exactamente la cantidad necesaria. Ejemplo: quedan 200 ml de agua, 150 de leche y 24 g de café, y se pide un latte (200, 150, 24). La máquina responde "Sorry there is not enough water", aunque sí alcanza. La condición correcta es >: solo falta el ingrediente si se necesita más de lo que hay.

🛠️ Nota técnica: el curso encuentra un error al pegar el mensaje desde el PDF: las comillas tipográficas (“ ”) no son comillas de programación (" "). Verificado: print(“hola”) produce SyntaxError: invalid character '“' (U+201C). Ocurre mucho al copiar código de documentos de Word, PDF o presentaciones.

Versión 4 — Procesar las monedas (requisito 5):

def process_coins():
    """Devuelve el total calculado a partir de las monedas insertadas."""
    print("Please insert coins.")
    total = int(input("how many quarters?: ")) * 0.25
    total += int(input("how many dimes?: ")) * 0.1
    total += int(input("how many nickles?: ")) * 0.05
    total += int(input("how many pennies?: ")) * 0.01
    return total

La primera línea crea total; las demás suman con +=. El curso recomienda un docstring en toda función que devuelva algo: al pasar el ratón sobre la llamada, PyCharm lo muestra.

Versión 5 — ¿El pago alcanza? (requisito 6):

def is_transaction_successful(money_received, drink_cost):
    """Devuelve True cuando se acepta el pago y False si el dinero no alcanza."""
    if money_received >= drink_cost:
        change = round(money_received - drink_cost, 2)
        print(f"Here is ${change} in change.")
        global profit
        profit += drink_cost
        return True
    else:
        print("Sorry that's not enough money. Money refunded.")
        return False

Lo que el curso destaca aquí:

• global profit: profit está fuera de la función. Para modificarla desde dentro hay que declararla global (Día 12). Sin esa línea, PyCharm marca un error.
• Código inalcanzable: si pones el return False antes del print, el print nunca se ejecuta y PyCharm lo resalta ("This code is unreachable").
• round(numero, 2): redondea a 2 decimales. En la prueba del curso, el cambio fue de $2,42.

Versión final — Preparar el café (requisito 7):

def make_coffee(drink_name, order_ingredients):
    """Descuenta los ingredientes necesarios de los recursos."""
    for item in order_ingredients:
        resources[item] -= order_ingredients[item]
    print(f"Here is your {drink_name} ☕️. Enjoy!")

Y el bloque else del bucle principal queda como una cadena de condiciones:

    else:
        drink = MENU[choice]
        if is_resource_sufficient(drink["ingredients"]):
            payment = process_coins()
            if is_transaction_successful(payment, drink["cost"]):
                make_coffee(choice, drink["ingredients"])

Así se lee el camino hasta el café: la máquina está encendida → no es off ni report → hay recursos → el pago alcanza → se prepara. El curso concluye que "cuanto más claro tengas el papel de cada función, más fácil será desenredar la lógica".

Pruebas#

🧪 Prueba y depuración#

La solución del curso cumple los requisitos, pero tiene cuatro problemas que puedes descubrir probándola:

1. Recursos exactos: la condición >= rechaza pedidos que sí se pueden preparar (nota técnica de la versión 3). Crea un caso de prueba que lo demuestre y corrígelo.
2. Bebida mal escrita: si el usuario escribe late o Latte, MENU[choice] produce KeyError: 'late' (verificado) y la máquina se apaga. Una máquina real no debería "romperse" por un error de tecleo. (Pistas: .lower(), if choice in MENU.)
3. Monedas vacías o con letras: si el usuario pulsa Enter sin escribir, int("") produce ValueError: invalid literal for int() with base 10: '' (verificado).
4. Decimales del dinero: los float no representan exactamente los centavos. Verificado: 0.1 * 3 da 0.30000000000000004. Aquí round corrige el cambio, pero las ganancias (profit) se suman sin redondear y, tras muchas ventas, el informe podría mostrar algo como $7.499999999. (Solución profesional: trabajar en centavos enteros, por ejemplo 250 en lugar de 2.5, y dividir entre 100 solo al mostrar.)

⭐ Extensión del proyecto#

• Una palabra secreta refill para reabastecer los ingredientes.
• Mostrar el menú con los precios formateados: f"{precio:.2f}".
• Contar cuántas bebidas de cada tipo se vendieron y mostrarlo en el informe.

¿Qué viene después? En el Día 16 se reconstruye esta misma máquina con programación orientada a objetos y se comparan las dos versiones.

Situación#

El consejo de padres quiere una máquina expendedora para la tienda escolar que venda refrigerios saludables y reciba monedas colombianas.

Requisitos#

1. Un diccionario PRODUCTOS con al menos 5 productos (por ejemplo, fruta picada, yogur, agua, arepa, avena), cada uno con precio en pesos y unidades disponibles.
2. Monedas aceptadas: $50, $100, $200, $500 y $1.000. Trabaja solo con enteros: en pesos no hay decimales, así que el problema de los float desaparece.
3. Palabras secretas: apagar, inventario (unidades de cada producto y dinero recaudado) y surtir (pide el producto y la cantidad a agregar).
4. Si un producto se agota, se informa y se sugiere otro disponible.
5. Cambio con el menor número de monedas: en vez de solo decir "Su cambio es $700", indica qué monedas entregar (por ejemplo, 1 de $500 y 1 de $200). (Pista: divisiones enteras // y residuos %, del Día 2.)
6. Validación: el programa no se detiene ante una opción inexistente o una cantidad de monedas que no sea un número.
7. Todas las funciones con docstring y sin global (pasa y devuelve los datos como parámetros y resultados).

Decisiones que debes tomar#

• ¿Cómo evitas usar global para el dinero recaudado?
• ¿Tu algoritmo de cambio funciona si la máquina no tiene suficientes monedas de un tipo? (Reto extra: lleva también el inventario de monedas.)

Reflexión#

Compara tu programa con la Máquina de Café: ¿qué funciones reutilizaste casi iguales? ¿Qué cambió por trabajar con pesos enteros?

Situación problema#

En la feria empresarial del colegio, cada curso tiene un puesto de venta. Se necesita un programa de caja por puesto que registre las ventas, controle el inventario y produzca un cierre del día.

Pregunta orientadora#

¿Cómo descomponer un sistema real en funciones pequeñas, verificables y fáciles de mantener?

Requerimientos#

1. Planificación en el editor: antes de programar, escribe todos los requisitos como # TODO numerados. Entrega una captura de la pestaña TODO.
2. Inventario inicial en un diccionario anidado: producto → precio, unidades y costo de producción.
3. Menú con las opciones: vender, inventario, cierre, salir.
4. Vender: permite varios productos en una misma venta (un "carrito"), valida que haya existencias antes de cobrar, recibe el pago en efectivo y calcula el cambio.
5. Cierre: total vendido, unidades vendidas por producto, ganancia (ventas − costos) y el producto más vendido.
6. Precios y dinero en enteros (pesos).
7. Ninguna entrada inválida detiene el programa.
8. Ninguna variable global: el estado se pasa y se devuelve entre funciones.

Etapas de desarrollo#

1. TODOs y diseño de las funciones (nombre, qué recibe, qué devuelve).
2. Inventario y menú.
3. Ventas de un solo producto.
4. Carrito con varios productos.
5. Cierre del día y validaciones.

Entregables#

• main.py con docstrings en todas las funciones.
• Captura de la pestaña TODO al inicio y al final (todos resueltos).
• Tabla de al menos 8 casos de prueba con los resultados.
• Registro de depuración: 3 errores que encontraste con el depurador o con print y cómo los resolviste.

Casos de prueba#

Criterios técnicos#

• Cada función hace una sola cosa y su nombre lo dice.
• El programa se ejecuta desde PyCharm (o VS Code) en un proyecto propio, no en el navegador.

Conceptuales#

1. ¿Qué diferencia hay entre Python, el intérprete, y PyCharm?
2. ¿Para qué sirven los comentarios # TODO?
3. ¿Por qué is_transaction_successful necesita global profit, pero make_coffee puede modificar resources sin global? (Pista: ¿se reasigna la variable o se modifica el diccionario?)

Análisis de código#

def f(pedido):
    for item in pedido:
        if pedido[item] > resources[item]:
            return False
    return True

Con resources = {"water": 100, "milk": 50, "coffee": 76}, ¿qué devuelve f({"water": 50, "coffee": 18})? ¿Y f({"water": 200, "milk": 150, "coffee": 24})?

Predicción#

¿Qué imprime round(2.675, 2)? Pruébalo. Si el resultado te sorprende, investiga por qué y relaciónalo con el problema 4 de la sección 🧪.

Depuración#

def process_coins():
    print("Please insert coins.")
    total = int(input("quarters?: ")) * 0.25
    total = int(input("dimes?: ")) * 0.1
    return total
    print(f"Total: {total}")

Encuentra dos problemas.

Modificación#

Agrega una cuarta bebida, mocha, con chocolate como ingrediente nuevo. ¿Qué dos diccionarios debes modificar? ¿Hay que cambiar alguna función?

Creación#

Escribe report() como función que devuelva el informe como un string (en lugar de imprimirlo), y úsala en el bucle principal.