Los operadores en Python con práctica real es lo que toca ahora, en el artículo anterior vimos la teoría. Ahora toca escribir código real. En este artículo construimos tres programas desde cero en VS Code usando todos los operadores que aprendiste: un conversor de unidades, una calculadora de descuentos y una calculadora completa con menú. Cada programa va de más simple a más completo — igual que en los ejercicios de clase.

Antes de empezar asegúrate de tener VS Code configurado. Crea una carpeta nueva llamada practica_operadores y dentro crea un archivo para cada programa.

Practicar los operadores en Python con práctica real es la mejor forma de afianzarlos, recomiendo además el uso de pythontutor.com para visualizar paso a paso lo que está ocurriendo.

Operadores en Python con práctica — Programa 1: Conversor de unidades

Crea el archivo conversor.py. Este programa convierte entre las unidades más usadas en el día a día:

# Conversor de unidades
print("=== CONVERSOR DE UNIDADES ===\n")

# Entrada
valor = float(input("Introduce el valor a convertir: "))

print("\n--- Distancia ---")
km_a_millas = round(valor * 0.621371, 4)
millas_a_km  = round(valor * 1.60934, 4)
print(f"{valor} km → {km_a_millas} millas")
print(f"{valor} millas → {millas_a_km} km")

print("\n--- Peso ---")
kg_a_libras = round(valor * 2.20462, 4)
libras_a_kg = round(valor * 0.453592, 4)
print(f"{valor} kg → {kg_a_libras} libras")
print(f"{valor} libras → {libras_a_kg} kg")

print("\n--- Temperatura ---")
celsius_a_fahrenheit = round((valor * 9/5) + 32, 2)
fahrenheit_a_celsius = round((valor - 32) * 5/9, 2)
print(f"{valor} °C → {celsius_a_fahrenheit} °F")
print(f"{valor} °F → {fahrenheit_a_celsius} °C")
```

Resultado con valor 100:
```
=== CONVERSOR DE UNIDADES ===

--- Distancia ---
100 km → 62.1371 millas
100 millas → 160.934 km

--- Peso ---
100 kg → 220.462 libras
100 libras → 45.3592 kg

--- Temperatura ---
100 °C → 212.0 °F
100 °F → 37.78 °C

Fíjate en lo que usamos aquí, * para multiplicar las conversiones, / para la temperatura, + y - también en temperatura, round() para controlar decimales, y f-strings para mostrar todo limpio. Todos los operadores aritméticos en acción.

Programa 2 — Calculadora de descuentos

Crea el archivo descuentos.py. Muy útil para entender cómo funciona el operador % en contexto real — aquí sí es porcentaje matemático, no módulo:

# Calculadora de descuentos y precios
print("=== CALCULADORA DE DESCUENTOS ===\n")

producto = input("Nombre del producto: ")
precio_original = float(input("Precio original (€): "))
descuento_pct = float(input("Descuento (%): "))

# Cálculos
descuento_euros = round(precio_original * descuento_pct / 100, 2)
precio_final = round(precio_original - descuento_euros, 2)
iva = round(precio_final * 0.21, 2)
precio_con_iva = round(precio_final + iva, 2)
ahorro_real = round(precio_original - precio_final, 2)

# Resultado detallado
print(f"\n--- Desglose de {producto} ---")
print(f"Precio original:     {precio_original} €")
print(f"Descuento ({int(descuento_pct)}%):      -{descuento_euros} €")
print(f"Precio con descuento: {precio_final} €")
print(f"IVA (21%):           +{iva} €")
print(f"Precio final con IVA: {precio_con_iva} €")
print(f"\nAhorro total:        {ahorro_real} €")
```

Resultado:
```
=== CALCULADORA DE DESCUENTOS ===

Nombre del producto: Portátil
Precio original (€): 899
Descuento (%): 15

--- Desglose de Portátil ---
Precio original:      899.0 €
Descuento (15%):      -134.85 €
Precio con descuento: 764.15 €
IVA (21%):            +160.47 €
Precio final con IVA: 924.62 €

Ahorro total:         134.85 €

Aquí usamos * y / para calcular porcentajes, - y + para aplicarlos, y round() en cada paso para evitar errores de decimales acumulados. Fíjate que el IVA se aplica sobre el precio con descuento, no sobre el original, ese es el cálculo correcto.

Programa 3 — Calculadora completa con menú

Este es el más ambicioso. Crea el archivo calculadora.py. Usa el operador % como módulo para detectar divisiones exactas, y // para la división entera:

# Calculadora completa con menú
print("=== CALCULADORA PYTHON ===")
print("1. Suma")
print("2. Resta")
print("3. Multiplicación")
print("4. División")
print("5. División entera")
print("6. Módulo (resto)")
print("7. Potencia")

opcion = int(input("\nElige una opción (1-7): "))
a = float(input("Primer número: "))
b = float(input("Segundo número: "))

print("\n--- Resultado ---")

if opcion == 1:
    resultado = a + b
    print(f"{a} + {b} = {resultado}")

elif opcion == 2:
    resultado = a - b
    print(f"{a} - {b} = {resultado}")

elif opcion == 3:
    resultado = a * b
    print(f"{a} × {b} = {resultado}")

elif opcion == 4:
    if b != 0:
        resultado = round(a / b, 4)
        print(f"{a} / {b} = {resultado}")
    else:
        print("Error: no se puede dividir entre cero")

elif opcion == 5:
    if b != 0:
        resultado = int(a // b)
        resto = int(a % b)
        print(f"{int(a)} // {int(b)} = {resultado} (resto: {resto})")
    else:
        print("Error: no se puede dividir entre cero")

elif opcion == 6:
    if b != 0:
        resultado = int(a % b)
        print(f"{int(a)} % {int(b)} = {resultado}")
        if resultado == 0:
            print(f"→ {int(a)} es divisible por {int(b)}")
        else:
            print(f"→ {int(a)} NO es divisible por {int(b)}")
    else:
        print("Error: no se puede dividir entre cero")

elif opcion == 7:
    resultado = a ** b
    print(f"{a} ^ {b} = {resultado}")

else:
    print("Opción no válida")
```

Resultado con opción 5 (división entera):
```
=== CALCULADORA PYTHON ===
1. Suma
...
Elige una opción (1-7): 5
Primer número: 17
Segundo número: 5

--- Resultado ---
17 // 5 = 3 (resto: 2)

Este programa ya usa estructuras if/elif/else que veremos en profundidad en el Tema 3, pero el funcionamiento es intuitivo. Lo importante aquí es ver cómo cada operador produce un resultado diferente con los mismos números.

El truco del operador % que más usarás

De todos los operadores el que más confunde y más se usa en ejercicios de FP1 es %. Aquí tienes los tres casos más típicos:

# ¿Es par o impar?
numero = 7
print(numero % 2 == 0)    # → False (impar)
print(numero % 2 == 1)    # → True  (impar confirmado)

# ¿Es divisible por N?
print(15 % 3 == 0)        # → True  (15 es divisible por 3)
print(16 % 3 == 0)        # → False (16 no es divisible por 3)

# Extraer los dígitos de un número
numero = 1234
unidades  = numero % 10          # → 4
decenas   = (numero // 10) % 10  # → 3
centenas  = (numero // 100) % 10 # → 2
millares  = (numero // 1000)     # → 1

Ese último ejemplo, extraer dígitos con % y // combinados, no aparece con mucha frecuencia pero sigue siendo relevante.

Resumen y siguiente paso

En este artículo practicaste los operadores en Python con tres programas reales. Los conceptos clave fueron * y / para conversiones y porcentajes, // para división entera, % para restos y divisibilidad, y cómo combinar operadores con round() y f-strings para resultados limpios.

En el siguiente artículo de esta serie encontrarás ejercicios propuestos con solución para practicar por tu cuenta.

---

Python operators practice — 3 real programs in VS Code

In the previous article we covered Python operators theory. Now let’s write real code. Three programs, each building on the last, unit converter, discount calculator, and a full calculator with menu.

Create a new folder called operators_practice and a separate file for each program.

Program 1 — Unit converter

# Unit converter
print("=== UNIT CONVERTER ===\n")

value = float(input("Enter value to convert: "))

print("\n--- Distance ---")
print(f"{value} km → {round(value * 0.621371, 4)} miles")
print(f"{value} miles → {round(value * 1.60934, 4)} km")

print("\n--- Weight ---")
print(f"{value} kg → {round(value * 2.20462, 4)} lbs")
print(f"{value} lbs → {round(value * 0.453592, 4)} kg")

print("\n--- Temperature ---")
print(f"{value} °C → {round((value * 9/5) + 32, 2)} °F")
print(f"{value} °F → {round((value - 32) * 5/9, 2)} °C")

Program 2 — Discount calculator

# Discount calculator
print("=== DISCOUNT CALCULATOR ===\n")

product = input("Product name: ")
original_price = float(input("Original price (€): "))
discount_pct = float(input("Discount (%): "))

discount_euros = round(original_price * discount_pct / 100, 2)
final_price = round(original_price - discount_euros, 2)
vat = round(final_price * 0.21, 2)
price_with_vat = round(final_price + vat, 2)
savings = round(original_price - final_price, 2)

print(f"\n--- {product} breakdown ---")
print(f"Original price:      {original_price} €")
print(f"Discount ({int(discount_pct)}%):       -{discount_euros} €")
print(f"Price after discount: {final_price} €")
print(f"VAT (21%):           +{vat} €")
print(f"Final price with VAT: {price_with_vat} €")
print(f"\nTotal savings:       {savings} €")

Program 3 — Full calculator with menu

# Full calculator
print("=== PYTHON CALCULATOR ===")
print("1. Addition\n2. Subtraction\n3. Multiplication")
print("4. Division\n5. Floor division\n6. Modulo\n7. Power")

option = int(input("\nChoose option (1-7): "))
a = float(input("First number: "))
b = float(input("Second number: "))

print("\n--- Result ---")

if option == 1:
    print(f"{a} + {b} = {a + b}")
elif option == 2:
    print(f"{a} - {b} = {a - b}")
elif option == 3:
    print(f"{a} × {b} = {a * b}")
elif option == 4:
    if b != 0:
        print(f"{a} / {b} = {round(a / b, 4)}")
    else:
        print("Error: cannot divide by zero")
elif option == 5:
    if b != 0:
        print(f"{int(a)} // {int(b)} = {int(a // b)} (remainder: {int(a % b)})")
    else:
        print("Error: cannot divide by zero")
elif option == 6:
    if b != 0:
        result = int(a % b)
        print(f"{int(a)} % {int(b)} = {result}")
        print(f"→ {int(a)} {'is' if result == 0 else 'is NOT'} divisible by {int(b)}")
    else:
        print("Error: cannot divide by zero")
elif option == 7:
    print(f"{a} ^ {b} = {a ** b}")
else:
    print("Invalid option")

The % trick you’ll use most

# Even or odd
print(7 % 2 == 0)     # → False (odd)

# Divisibility
print(15 % 3 == 0)    # → True

# Extract digits
n = 1234
units    = n % 10           # → 4
tens     = (n // 10) % 10   # → 3
hundreds = (n // 100) % 10  # → 2

That last one, extracting digits with % and // — doesn’t appears frequently.

Summary and Next Steps

In this article, you practiced Python operators with three real programs. The key concepts were * and / for conversions and percentages, // for integer division, % for remainders and divisibility, and how to combine operators with round() and f-strings for clean results.

In the next article in this series, you’ll find practice exercises with solutions for you to use on your own.