De la lógica al
código que funciona
Operadores, condicionales, ciclos y funciones: las cuatro herramientas que convierten un algoritmo en papel en un programa real. Al terminar esta parte, construirás tu primera aplicación funcional.
Operadores: las herramientas de cálculo y comparación
Si las variables son las cajas donde guardas datos, los operadores son las herramientas que usas para trabajar con esos datos: sumar, restar, comparar, combinar lógicas. Sin operadores, un programa solo puede almacenar información pero nunca transformarla ni tomar decisiones basadas en ella.
Tienes materiales (variables), pero necesitas herramientas para trabajar con ellos. Un + es como el pegamento que une dos piezas. Un > es como la regla que mide y compara. Un and es como el tornillo que necesita DOS condiciones para apretar. Cada operador hace una cosa específica y bien definida.
Tipo 1: Operadores aritméticos
Realizan operaciones matemáticas. Son los más directos: los mismos que conoces de la escuela, con una pequeña adición.
# Calculadora: aplicando los 4 operadores básicos num1 = 150.0 num2 = 4.0 print(num1 + num2) # 154.0 → suma print(num1 - num2) # 146.0 → resta print(num1 * num2) # 600.0 → multiplicación print(num1 / num2) # 37.5 → división con decimales # Inventario: calcular valor total de productos precio_unitario = 299.99 cantidad_en_stock = 35 valor_total = precio_unitario * cantidad_en_stock print(f"Valor en inventario: ${valor_total:.2f}") # Valor en inventario: $10499.65
Tipo 2: Operadores de comparación
Comparan dos valores y siempre devuelven True (verdadero) o False (falso). Son la base de todas las decisiones que tomará tu programa.
| Operador | Significado | Ejemplo | Resultado |
|---|---|---|---|
== | ¿Son iguales? | 5 == 5 | True |
!= | ¿Son diferentes? | 5 != 3 | True |
> | ¿Es mayor? | 10 > 7 | True |
< | ¿Es menor? | 3 < 1 | False |
>= | ¿Mayor o igual? | 5 >= 5 | True |
<= | ¿Menor o igual? | 4 <= 3 | False |
Tipo 3: Operadores lógicos
Combinan varias comparaciones en una sola condición. Imprescindibles cuando necesitas que se cumplan dos cosas a la vez, o al menos una de ellas.
stock = 5 precio = 199.99 disponible = True # AND → ambas condiciones deben ser True print(stock > 0 and disponible) # True → hay stock Y está disponible print(stock > 0 and precio < 100) # False → hay stock pero precio no es < 100 # OR → al menos una condición debe ser True print(stock == 0 or precio > 100) # True → precio sí es > 100 # NOT → invierte el resultado print(not disponible) # False → disponible era True, not lo invierte
En la calculadora usarás operadores aritméticos para calcular. En el inventario usarás operadores de comparación para verificar si hay stock suficiente antes de descontarlo. En la lección siguiente (condicionales) pondrás estos operadores en acción dentro de decisiones reales.
stock = 3 y el cliente quiere comprar 5 unidades. ¿Qué expresión verifica si hay stock suficiente?Condicionales: enseña a tu programa a tomar decisiones
Un programa sin condicionales siempre hace lo mismo, sin importar lo que pase. Los condicionales son la estructura que permite que tu programa evalúe una situación y elija qué camino seguir. Son el equivalente al rombo del diagrama de flujo que aprendiste en la lección 3, ahora escrito en código real.
Un semáforo evalúa una condición (color de la luz) y decide qué instrucción ejecutar: rojo = detenerse, amarillo = precaución, verde = avanzar. Tu programa hace exactamente lo mismo: evalúa una condición con los operadores de la lección anterior y elige qué bloque de código ejecutar.
Estructura if / elif / else
# Estructura completa de un condicional if <condición 1>: # se ejecuta si condición 1 es True elif <condición 2>: # se ejecuta si condición 1 es False y condición 2 es True elif <condición 3>: # puedes tener tantos elif como necesites else: # se ejecuta si NINGUNA condición anterior fue True # ⚠ La indentación (sangría de 4 espacios) es OBLIGATORIA en Python. # Sin ella, el programa falla o hace cosas inesperadas.
La calculadora con condicionales: código real
Aquí está el núcleo de la calculadora del proyecto, aplicando todo lo aprendido hasta ahora:
# Recibir datos del usuario (lo envolveremos en funciones en L8) num1 = float(input("Primer número: ")) operador = input("Operador (+ - * /): ") num2 = float(input("Segundo número: ")) # Lógica de decisión — el corazón de la calculadora if operador == "+": resultado = num1 + num2 elif operador == "-": resultado = num1 - num2 elif operador == "*": resultado = num1 * num2 elif operador == "/": if num2 != 0: # condicional anidado: evita división por cero resultado = num1 / num2 else: print("❌ Error: no se puede dividir entre cero.") resultado = None else: print("❌ Operador no reconocido. Usa: + - * /") resultado = None if resultado is not None: print(f"✅ Resultado: {num1} {operador} {num2} = {resultado}")
El inventario con condicionales: verificar stock
producto = "Teclado Mecánico" cantidad_en_stock = 8 unidades_a_vender = int(input("¿Cuántas unidades desea comprar? ")) if unidades_a_vender <= 0: print("❌ La cantidad debe ser mayor a cero.") elif unidades_a_vender <= cantidad_en_stock: cantidad_en_stock -= unidades_a_vender # -= es atajo de x = x - n print(f"✅ Venta realizada. Stock restante: {cantidad_en_stock}") else: print(f"❌ Stock insuficiente. Solo hay {cantidad_en_stock} unidades.")
Python usa la sangría (4 espacios) para saber qué código pertenece a cada bloque. Si mezclas espacios y tabulaciones, o pones código mal alineado, obtendrás un IndentationError. Configura tu editor para que Tab = 4 espacios automáticamente.
stock = 0?if stock > 0: print("Hay stock") elif stock == 0: print("Agotado") else: print("Error")Ciclos: repite sin cansarte ni equivocarte
Los ciclos (también llamados bucles o loops) permiten ejecutar un bloque de código múltiples veces sin tener que escribirlo repetidamente. Son la forma en que los programas hacen tareas masivas en segundos: procesar 10,000 productos del inventario, pedirle al usuario que lo intente de nuevo si escribe algo incorrecto, o mantener la calculadora funcionando hasta que el usuario decida salir.
Una lavadora no lava una prenda y se apaga. Ejecuta el mismo ciclo (mojar, girar, enjuagar) una y otra vez hasta cumplir la condición de salida (el tiempo programado). Tu programa funciona igual: repite instrucciones hasta que una condición dice "ya terminamos".
El ciclo while: repite mientras algo sea verdadero
Se usa cuando no sabes de antemano cuántas veces se repetirá el ciclo. Se ejecuta mientras la condición sea True y se detiene cuando se vuelve False.
# El while mantiene el programa vivo hasta que el usuario quiera salir continuar = True while continuar: print("\n===== MENÚ PRINCIPAL =====") print("1. Calculadora") print("2. Inventario") print("3. Salir") opcion = input("Elige una opción: ") if opcion == "1": print("→ Abriendo calculadora...") elif opcion == "2": print("→ Abriendo inventario...") elif opcion == "3": print("¡Hasta luego!") continuar = False # la condición se vuelve False → el ciclo termina else: print("❌ Opción inválida. Intenta de nuevo.") # continuar sigue True → el ciclo se repite automáticamente
El ciclo for: repite un número conocido de veces
Se usa cuando sabes exactamente cuántas veces necesitas repetir, o cuando quieres recorrer una lista de elementos uno por uno.
# Lista de productos en el inventario inventario = [ {"nombre": "Laptop", "stock": 12, "precio": 15999.99}, {"nombre": "Mouse", "stock": 45, "precio": 349.00}, {"nombre": "Teclado", "stock": 8, "precio": 899.50}, {"nombre": "Monitor", "stock": 3, "precio": 5499.00}, ] print("\n----- INVENTARIO ACTUAL -----") for producto in inventario: # recorre cada producto de la lista nombre = producto["nombre"] stock = producto["stock"] precio = producto["precio"] # Condicional dentro del ciclo: alerta de stock bajo if stock < 5: alerta = "⚠ STOCK BAJO" else: alerta = "" print(f" {nombre:10} | Stock: {stock:3} | ${precio:8.2f} {alerta}") # Salida: # Laptop | Stock: 12 | $15999.99 # Mouse | Stock: 45 | $349.00 # Teclado | Stock: 8 | $899.50 # Monitor | Stock: 3 | $5499.00 ⚠ STOCK BAJO
break detiene el ciclo inmediatamente y sale de él aunque la condición todavía sea verdadera. continue salta el resto del bloque actual y vuelve al inicio del ciclo para la siguiente iteración. Ambos son herramientas de control avanzado que usarás en el proyecto final para manejar entradas inválidas.
Un while True: sin un break o una condición que cambie a False crea un bucle infinito: el programa se congela y nunca termina. Si te ocurre, presiona Ctrl + C en la terminal para forzar la detención. En el proyecto siempre tendremos una opción "Salir" que cambia la condición a False.
Funciones: organiza tu código en bloques reutilizables
Una función es un bloque de código con nombre que realiza una tarea específica y puede ser llamado (ejecutado) desde cualquier parte del programa, las veces que sea necesario. Las funciones son el principio de organización más importante en programación: convierten un programa largo y difícil de entender en módulos pequeños, claros y reutilizables.
En una fábrica, en lugar de que una persona haga todo el proceso, hay máquinas especializadas: una corta, otra suelda, otra pinta. Cada máquina recibe una entrada (material), hace su trabajo específico y entrega una salida (producto terminado). Las funciones son esas máquinas: reciben datos de entrada (parámetros), procesan y devuelven un resultado. Y lo mejor: puedes usar la misma máquina mil veces sin rediseñarla.
Anatomía de una función en Python
# Definir la función (solo se escribe UNA vez) def nombre_de_la_funcion(parametro1, parametro2): """Docstring: descripción de qué hace la función.""" # código que se ejecuta cuando se llama a la función resultado = parametro1 + parametro2 return resultado # devuelve el resultado al lugar donde fue llamada # Llamar / usar la función (se puede llamar N veces) mi_resultado = nombre_de_la_funcion(10, 25) print(mi_resultado) # 35
Las funciones de la calculadora
# ── Función 1: ejecutar el cálculo ────────────────────── def calcular(num1, operador, num2): """Recibe dos números y un operador. Retorna el resultado.""" if operador == "+": return num1 + num2 elif operador == "-": return num1 - num2 elif operador == "*": return num1 * num2 elif operador == "/": if num2 != 0: return num1 / num2 print("❌ División por cero no permitida.") return None print("❌ Operador no válido.") return None # ── Función 2: mostrar la calculadora al usuario ───────── def menu_calculadora(): """Pide datos al usuario y muestra el resultado.""" print("\n🧮 CALCULADORA") n1 = float(input(" Primer número : ")) op = input(" Operador (+,-,*,/): ") n2 = float(input(" Segundo número: ")) res = calcular(n1, op, n2) # llama a la función calcular if res is not None: print(f" ✅ {n1} {op} {n2} = {res}")
Las funciones del inventario
# ── Función 3: agregar producto ────────────────────────── def agregar_producto(inventario): """Solicita datos y agrega un producto nuevo a la lista.""" print("\n➕ AGREGAR PRODUCTO") nombre = input(" Nombre del producto: ") precio = float(input(" Precio unitario : $")) stock = int(input(" Cantidad en stock : ")) inventario.append({ "nombre": nombre, "precio": precio, "stock": stock }) print(f" ✅ '{nombre}' agregado al inventario.") # ── Función 4: mostrar todos los productos ─────────────── def ver_inventario(inventario): """Muestra todos los productos con alerta de stock bajo.""" print("\n📦 INVENTARIO ACTUAL") if not inventario: print(" (Sin productos registrados)") return for p in inventario: alerta = "⚠ STOCK BAJO" if p["stock"] < 5 else "" print(f" {p['nombre']:15}| Stock:{p['stock']:4} | ${p['precio']:8.2f} {alerta}")
Las funciones son la implementación del principio más importante del buen código: no te repitas. Si necesitas hacer lo mismo en tres partes del programa, no copies el código tres veces — escribe una función y llámala tres veces. Cuando haya un error, solo lo corriges en un lugar.
return en una función en lugar de solo imprimir el resultado con print?Calculadora + Sistema de Inventario Básico
Este es el momento para el que trabajaste todo el módulo. Cada concepto aprendido — variables, operadores, condicionales, ciclos y funciones — es un ingrediente de este programa. Aquí los unes todos en una aplicación real y funcional.
- ✅Menú principal con ciclo while que mantiene el programa activo
- ✅Calculadora con las 4 operaciones y validación de división por cero
- ✅Agregar productos al inventario con nombre, precio y stock
- ✅Ver inventario completo con alerta automática de stock bajo
- ✅Vender unidades con validación de stock suficiente
- ✅Todo organizado en funciones — código limpio y profesional
El código completo — listo para ejecutar
# ============================================================ # PROYECTO FINAL · Módulo 1 · Fundamentos de Programación # Calculadora + Sistema de Inventario Básico # Herramientas usadas: variables, operadores, condicionales, # ciclos (while, for) y funciones. # ============================================================ # ── SECCIÓN 1: CALCULADORA ─────────────────────────────── def calcular(num1, operador, num2): """Realiza una operación aritmética y retorna el resultado.""" if operador == "+": return num1 + num2 elif operador == "-": return num1 - num2 elif operador == "*": return num1 * num2 elif operador == "/": if num2 != 0: return num1 / num2 print(" ❌ Error: división por cero no permitida.") return None print(" ❌ Operador no válido. Usa: + - * /") return None def menu_calculadora(): """Interfaz de la calculadora: pide datos y muestra resultado.""" print("\n 🧮 CALCULADORA") print(" " + "-"*30) try: n1 = float(input(" Primer número : ")) op = input(" Operador : ").strip() n2 = float(input(" Segundo número : ")) except ValueError: print(" ❌ Ingresa solo números válidos.") return res = calcular(n1, op, n2) if res is not None: print(f" ✅ Resultado: {n1} {op} {n2} = {res}") # ── SECCIÓN 2: INVENTARIO ──────────────────────────────── def agregar_producto(inventario): """Agrega un nuevo producto al inventario.""" print("\n ➕ AGREGAR PRODUCTO") print(" " + "-"*30) try: nombre = input(" Nombre : ").strip() precio = float(input(" Precio $ : ")) stock = int(input(" Stock : ")) except ValueError: print(" ❌ Datos inválidos. Operación cancelada.") return if not nombre: print(" ❌ El nombre no puede estar vacío.") return inventario.append({"nombre":nombre, "precio":precio, "stock":stock}) print(f" ✅ '{nombre}' agregado correctamente.") def ver_inventario(inventario): """Muestra el inventario completo con alertas de stock bajo.""" print("\n 📦 INVENTARIO ACTUAL") print(" " + "-"*50) if not inventario: print(" (No hay productos registrados aún)") return for i, p in enumerate(inventario, 1): alerta = " ⚠ STOCK BAJO" if p["stock"] < 5 else "" print(f" {i}. {p['nombre']:18}| Stock:{p['stock']:4} | ${p['precio']:8.2f}{alerta}") total = sum(p["precio"] * p["stock"] for p in inventario) print(f"\n Valor total del inventario: ${total:,.2f}") def vender_producto(inventario): """Descuenta unidades del stock de un producto.""" print("\n 🛒 VENDER PRODUCTO") print(" " + "-"*30) if not inventario: print(" ❌ No hay productos en el inventario.") return ver_inventario(inventario) try: idx = int(input("\n Número de producto: ")) - 1 cant = int(input(" Unidades a vender: ")) except ValueError: print(" ❌ Entrada inválida.") return if idx < 0 or idx >= len(inventario): print(" ❌ Número de producto no existe.") return prod = inventario[idx] if cant <= 0: print(" ❌ La cantidad debe ser mayor a cero.") elif cant <= prod["stock"]: prod["stock"] -= cant total_venta = cant * prod["precio"] print(f" ✅ Venta: {cant} x {prod['nombre']} = ${total_venta:.2f}") print(f" Stock restante: {prod['stock']}") else: print(f" ❌ Stock insuficiente. Disponibles: {prod['stock']}") # ── SECCIÓN 3: MENÚ PRINCIPAL ──────────────────────────── def main(): """Punto de entrada del programa: menú principal con while.""" inventario = [] # lista vacía que almacenará todos los productos print("="*40) print(" SISTEMA: Calculadora + Inventario") print("="*40) while True: # ciclo principal — siempre activo hasta que el usuario salga print("\n ¿Qué deseas hacer?") print(" 1. Calculadora") print(" 2. Ver inventario") print(" 3. Agregar producto") print(" 4. Registrar venta") print(" 5. Salir") opcion = input("\n Elige (1-5): ").strip() if opcion == "1": menu_calculadora() elif opcion == "2": ver_inventario(inventario) elif opcion == "3": agregar_producto(inventario) elif opcion == "4": vender_producto(inventario) elif opcion == "5": print("\n ¡Hasta luego! 👋\n") break # sale del while True else: print(" ❌ Opción inválida. Elige entre 1 y 5.") # ── EJECUTAR EL PROGRAMA ───────────────────────────────── main() # esta línea lanza todo el programa
¿Qué concepto de cada lección está en el proyecto?
| Lección | Concepto | Dónde aparece en el proyecto |
|---|---|---|
| L1 | ¿Qué es programar? | El programa entero: instrucciones que resuelven un problema real |
| L2 | Algoritmos | La lógica de calcular() y vender_producto() pensada antes de codificar |
| L3 | Diagramas de flujo | El flujo del menú principal: inicio → opción → acción → repetir o salir |
| L4 | Variables | inventario, num1, precio, stock, opcion… |
| L5 | Operadores | num1 + num2, stock -= cant, cant <= stock, idx >= len()… |
| L6 | Condicionales | Toda decisión: if/elif/else en la calculadora, la venta y el menú |
| L7 | Ciclos | while True en el menú principal, for p in inventario para listar |
| L8 | Funciones | calcular(), menu_calculadora(), agregar_producto(), ver_inventario(), vender_producto(), main() |
Cómo ejecutar el proyecto
Instala Python
Descarga Python 3.x desde python.org. Es gratuito y disponible para Windows, Mac y Linux.
Crea el archivo
Crea un archivo llamado calculadora_inventario.py y pega el código completo del proyecto.
Ejecuta en terminal
Abre una terminal en la carpeta del archivo y escribe: python calculadora_inventario.py
Prueba todos los flujos
Prueba la calculadora, agrega 3 productos, vende unidades y verifica que el stock se actualice.
Una vez que el proyecto funciona, amplíalo: (1) Agrega la opción de eliminar un producto del inventario. (2) Calcula el valor total de cada venta y acumúlalo en una variable de "ventas del día". (3) Muestra al final cuántos productos tienen stock bajo (menos de 5). Estos desafíos usan exactamente los mismos conceptos del módulo, solo aplicados de forma diferente.
¡Módulo 1 completado!
Dominaste los 8 fundamentos de la programación y construiste tu primera aplicación real en Python. Eso no es poco: la mayoría de personas nunca llega aquí.
El Módulo 2 te espera: Estructuras de datos avanzadas, archivos y programación orientada a objetos.
0 Comentarios