Operadores en Python — práctica con un conversor de unidades, el bono de cafés con IGIC en céntimos y una calculadora con negativos (y el céntimo que se me perdía)

El cuatrimestre pasado la cafetería de la facultad sacó un bono de 10 cafés con descuento para estudiantes. Me lo compré, y como estaba en plena semana de operadores de FP1, quise calcular con Python cuánto me salía cada café. Hice la cuenta con decimales, la dividí entre 10, multipliqué por 10 para comprobar… y no me daba lo que había pagado. Después lo hice en céntimos y descubrí que el problema no era Python: 1091 céntimos no se pueden repartir exactos entre 10 cafés. Sobra uno. La lección que me dejó es la que vas a ver en los tres programas de hoy: antes de operar, piensa en qué tipo de número tienes y qué tipo quieres obtener.

Esta es la práctica de la teoría de operadores en Python. Vas a escribir tres programas completos, de nivel medio, que usan todo lo que viste allí: un conversor de unidades (precedencia y paréntesis), una calculadora de descuentos con el bono de cafés, el IGIC canario y el dinero en céntimos (//, % y round) y una calculadora completa que enseña las siete operaciones aritméticas con números positivos y negativos (cociente, resto y comparaciones). Los datos se parecen a los de verdad: precios con céntimos, un impuesto que no sale redondo y un número negativo que hace que // no se comporte como esperas.

Antes de empezar

Conviene tener claro:

• Que / siempre devuelve un float y // devuelve el cociente entero, redondeado hacia abajo.
• Que % es el resto de la división, no un porcentaje, y que b * (a // b) + a % b siempre vuelve a dar a.
• La precedencia básica: ** antes que *, /, // y %, y estos antes que + y -.
• Que los float no se comparan con == y que el dinero se maneja mejor en céntimos.

Si alguno te suena dudoso, repasa la teoría antes de seguir.

Programa 1: conversor de unidades

Un mismo valor (100) convertido de kilómetros a millas y al revés, de kilos a libras y al revés y de grados Celsius a Fahrenheit y al revés. Las dos primeras conversiones son una simple multiplicación por un factor; la de temperatura es la que tiene truco, porque mezcla multiplicación, división y suma o resta, y ahí la precedencia decide si el resultado es correcto o un disparate.

La idea

Cada conversión es una fórmula. Las de distancia y peso son valor * factor, y los factores (0.621371, 1.60934…) son constantes: no cambian nunca, así que las guardamos en variables en mayúsculas al principio, para no escribir números mágicos repetidos por el código. Para la temperatura usamos las dos fórmulas de física: °F = °C × 9/5 + 32 y °C = (°F − 32) × 5/9. La segunda necesita paréntesis, la primera no. Y para entender por qué, el programa calcula también las dos versiones mal escritas.

El código

# Conversor de unidades: un mismo valor en distancia, peso y temperatura
valor = 100.0            # antes venía de input(); cámbialo para probar otros valores

# Factores de conversión: constantes, por eso van en MAYÚSCULAS
KM_A_MILLAS = 0.621371
MILLAS_A_KM = 1.60934
KG_A_LIBRAS = 2.20462
LIBRAS_A_KG = 0.453592

print("=== CONVERSOR DE UNIDADES ===")

print("--- Distancia ---")
print(valor, "km →", round(valor * KM_A_MILLAS, 4), "millas")
print(valor, "millas →", round(valor * MILLAS_A_KM, 4), "km")

print("--- Peso ---")
print(valor, "kg →", round(valor * KG_A_LIBRAS, 4), "libras")
print(valor, "libras →", round(valor * LIBRAS_A_KG, 4), "kg")

print("--- Temperatura ---")
c_a_f = valor * 9 / 5 + 32       # * y / antes que +: no hacen falta paréntesis
f_a_c = (valor - 32) * 5 / 9     # aquí SÍ: la resta tiene que ir primero
print(valor, "°C →", round(c_a_f, 2), "°F")
print(valor, "°F →", round(f_a_c, 2), "°C")

# Los dos errores típicos, calculados de verdad
sin_parentesis = valor - 32 * 5 / 9      # resta 17.78 en vez de restar 32 primero
con_doble_barra = valor * (9 // 5) + 32  # 9 // 5 vale 1: se pierde el 0.8
print("Sin paréntesis saldría:", round(sin_parentesis, 2), "°C")
print("Con // saldría:", con_doble_barra, "°F")

Salida

=== CONVERSOR DE UNIDADES ===
--- Distancia ---
100.0 km → 62.1371 millas
100.0 millas → 160.934 km
--- Peso ---
100.0 kg → 220.462 libras
100.0 libras → 45.3592 kg
--- Temperatura ---
100.0 °C → 212.0 °F
100.0 °F → 37.78 °C
Sin paréntesis saldría: 82.22 °C
Con // saldría: 132.0 °F

Comprobamos a mano: 100 × 0,621371 = 62,1371 millas, y 100 × 1,60934 = 160,934 km. En temperatura, 100 × 9 / 5 = 180 y 180 + 32 = 212 °F (el agua hierve a 212 °F, cuadra). Al revés, (100 − 32) = 68; 68 × 5 = 340; 340 / 9 = 37,777…, que round(…, 2) deja en 37.78 °C.

Ahora los dos errores, que no son inventados: el programa los calcula de verdad.

# Los dos errores típicos, calculados de verdad
sin_parentesis = valor - 32 * 5 / 9      # resta 17.78 en vez de restar 32 primero
con_doble_barra = valor * (9 // 5) + 32  # 9 // 5 vale 1: se pierde el 0.8

• Sin paréntesis, valor - 32 * 5 / 9 hace primero 32 × 5 = 160, luego 160 / 9 = 17,78 y por último 100 − 17,78 = 82.22 °C. Ni de lejos: 100 °F es un día de mucho calor, pero no de 82 °C.
• Con //, 9 // 5 vale 1 (el 0,8 se pierde), así que la fórmula se convierte en 100 × 1 + 32 = 132.0 °F en lugar de 212.

Mira los dos árboles: en cada nodo pone qué operación se hace y qué resultado sale, y se resuelven de abajo arriba.

Preguntas que te puedes hacer

¿Por qué valor * 9 / 5 + 32 no lleva paréntesis? Porque el orden natural ya es el correcto: * y / van antes que + y, entre ellos, de izquierda a derecha. Python hace (100 × 9) / 5 = 180 y después suma 32. Ponerle paréntesis, (valor * 9 / 5) + 32, no cambia nada, pero no está mal si te ayuda a leerlo.

¿Por qué los resultados salen como 100.0 y no 100? Porque valor es 100.0, un float, y cualquier operación con un float da float. En la versión antigua de este programa el valor venía de float(input(...)); aquí lo he dejado igual de tipo para que el comportamiento sea el mismo.

¿Por qué round(…, 4) en distancia y round(…, 2) en temperatura? Por lo que necesitas mostrar. Un factor como 0.621371 da muchos decimales y con 4 se ve bien la conversión; una temperatura con 2 decimales es más que suficiente. round cambia el valor que se imprime, pero las variables c_a_f y f_a_c conservan todos sus decimales.

¿Por qué 9 / 5 y no 1.8? Funcionaría igual (valor * 1.8 + 32), pero 9 / 5 se parece a la fórmula del libro y se comprueba de un vistazo. Lo importante es que sea / y no //.

Pruébalo tú

• Cambia valor a -40.0 y comprueba el dato curioso: −40 °C son exactamente −40 °F.
• Añade la conversión de metros a pies (1 m = 3.28084 pies) con su constante y sus dos líneas.

Programa 2: calculadora de descuentos con el bono de cafés

El bono de 10 cafés cuesta 12,00 €. Los estudiantes tienen un 15 % de descuento y sobre el precio rebajado se aplica el IGIC, el impuesto indirecto de Canarias (7 % el tipo general; en la península sería el IVA). El programa tiene que mostrar el desglose en euros con sus dos decimales y, además, cuánto sale cada café. Lo que lo complica: el impuesto no sale redondo (71,4 céntimos) y el total no se reparte exacto entre 10.

La idea

Todo el cálculo se hace en céntimos y con enteros, como en la teoría: 12,00 € son 1200 céntimos. Así, cada resultado intermedio es exacto. Los pasos, en orden:

1. Descuento = precio × 15 // 100. Primero se multiplica y después se divide, para no perder nada por el camino.
2. Precio con descuento = precio − descuento.
3. IGIC = 7 % del precio ya rebajado, redondeado al céntimo con round.
4. Total = precio rebajado + IGIC.
5. Para mostrarlo en euros: los euros son céntimos // 100 y los céntimos sueltos céntimos % 100.

Al final, para comparar, se hace la misma cuenta con float.

El código

# Bono de 10 cafés: descuento de estudiante e IGIC, todo en céntimos
producto = "Bono de 10 cafés"
precio_cent = 1200       # 12,00 € en céntimos: los enteros son exactos
descuento_pct = 15       # descuento de estudiante (%)
IGIC_PCT = 7             # IGIC general de Canarias (en la península, IVA)

# 1. Descuento: primero multiplicar, después dividir (// para quedarnos en enteros)
descuento_cent = precio_cent * descuento_pct // 100
con_descuento = precio_cent - descuento_cent

# 2. Impuesto sobre el precio YA rebajado; round() al céntimo más cercano
igic_cent = round(con_descuento * IGIC_PCT / 100)
total_cent = con_descuento + igic_cent

# 3. Mostrar euros: // da los euros y % los céntimos (:02d pone el cero: 05)
print("---", producto, "---")
print(f"Precio: {precio_cent // 100},{precio_cent % 100:02d} €")
print(f"Descuento ({descuento_pct} %): -{descuento_cent // 100},{descuento_cent % 100:02d} €")
print(f"Con descuento: {con_descuento // 100},{con_descuento % 100:02d} €")
print(f"IGIC ({IGIC_PCT} %): +{igic_cent // 100},{igic_cent % 100:02d} €")
print(f"Total: {total_cent // 100},{total_cent % 100:02d} €")

# 4. ¿Cuánto sale cada café? 1091 no se reparte exacto entre 10
por_cafe = total_cent // 10
sobra = total_cent % 10
print("Cada café:", por_cafe, "céntimos y sobra", sobra)
print("¿Cuadra?", por_cafe * 10 + sobra == total_cent)

# 5. La misma cuenta con floats, para comparar
con_floats = 12.00 * (1 - 0.15) * (1 + 0.07)
print("Con floats:", con_floats)
print("¿Igual que en céntimos?", con_floats == total_cent / 100)

Salida

--- Bono de 10 cafés ---
Precio: 12,00 €
Descuento (15 %): -1,80 €
Con descuento: 10,20 €
IGIC (7 %): +0,71 €
Total: 10,91 €
Cada café: 109 céntimos y sobra 1
¿Cuadra? True
Con floats: 10.914
¿Igual que en céntimos? False

Comprobamos a mano:

Paso	Cuenta	Resultado (céntimos)
Descuento	1200 × 15 = 18000; 18000 // 100	180
Con descuento	1200 − 180	1020
IGIC	1020 × 7 = 7140; 7140 / 100 = 71.4; round(71.4)	71
Total	1020 + 71	1091
Por café	1091 // 10	109
Sobra	1091 % 10	1

En el dibujo tienes el recorrido completo: de 1200 a 1091 con enteros, y cómo // y % sacan de 1091 tanto los euros y céntimos como el precio por café.

La parte que da formato al dinero merece un zoom:

print(f"Precio: {precio_cent // 100},{precio_cent % 100:02d} €")
print(f"Descuento ({descuento_pct} %): -{descuento_cent // 100},{descuento_cent % 100:02d} €")
print(f"Con descuento: {con_descuento // 100},{con_descuento % 100:02d} €")
print(f"IGIC ({IGIC_PCT} %): +{igic_cent // 100},{igic_cent % 100:02d} €")
print(f"Total: {total_cent // 100},{total_cent % 100:02d} €")

En cada línea, x // 100 son los euros enteros y x % 100 lo que sobra, los céntimos. El :02d dentro de las llaves rellena con un cero a la izquierda hasta tener dos cifras: sin él, 1200 céntimos se mostrarían como 12,0 € en lugar de 12,00 €, y 5 céntimos como 0,5 en lugar de 0,05.

Y el final, el de mi anécdota: 1091 // 10 son 109 céntimos por café y sobra 1. Si cobras 109 a cada café, recaudas 1090: falta un céntimo. Por eso el programa comprueba por_cafe * 10 + sobra == total_cent (109 × 10 + 1 = 1091): la cuenta cuadra solo si no te olvidas del resto.

Preguntas que te puedes hacer

¿Por qué precio_cent * descuento_pct // 100 y no precio_cent * (descuento_pct // 100)? Porque 15 // 100 es 0: el descuento saldría 0. Y aunque usaras /, 15 / 100 es 0.15, un float que vuelve a meter decimales. Multiplicar primero (1200 × 15 = 18000) y dividir después mantiene todo en enteros y es exacto. Como * y // están en el mismo escalón, Python ya lo hace de izquierda a derecha sin paréntesis.

¿Por qué en el IGIC uso / y round, y no //? Porque 71,4 céntimos se redondean al céntimo más cercano, que es 71, pero 71,6 se redondearía a 72. // siempre baja, así que con 71,6 daría 71 y cobrarías de menos. round es la operación que pide un ticket real.

¿Por qué el resultado con float es 10.914 y no 10.91? Porque la versión con decimales nunca redondea el impuesto al céntimo: arrastra el 0,4 hasta el final. Por eso con_floats == total_cent / 100 da False: no es solo el problema de los decimales binarios, es que son cuentas distintas. La de los céntimos es la que coincide con lo que te cobran.

¿Por qué el impuesto se aplica sobre el precio rebajado? Porque así funciona un ticket: primero el descuento, después el impuesto sobre lo que realmente pagas. Si lo calcularas sobre 1200 saldría 84 céntimos de IGIC en lugar de 71.

Pruébalo tú

• Cambia el descuento a 20 % y el precio a 1250 céntimos. Antes de ejecutar, calcula a mano el total y comprueba si sobra algo al repartir entre 10.
• Añade una línea que muestre el ahorro total en euros (precio original con IGIC menos total pagado), con el mismo formato // y %.

Programa 3: calculadora completa

La versión antigua de este programa tenía un menú para elegir la operación, pero para eso hacen falta los condicionales, que todavía no hemos visto. Esta calculadora hace todas las operaciones a la vez con el mismo par de números a y b, y después comprueba tres cosas con operadores de comparación y lógicos: si a es divisible entre b, si a es par y si se cumple la igualdad del cociente y el resto. Lo interesante es ejecutarla con tres parejas distintas, una de ellas negativa.

La idea

Cada línea es una f-string que muestra la operación y su resultado. Para las comprobaciones:

• Divisible: a % b == 0 (si no sobra nada, es divisible).
• Par: a % 2 == 0.
• La igualdad de la división: b * (a // b) + a % b == a. Si // y % son coherentes, esto da True siempre, también con negativos.
• Una comprobación protegida: b != 0 and a / b > 3. El b != 0 va delante para que, si alguna vez b vale 0, el and se pare antes de dividir.

El código

# Calculadora completa: todas las operaciones con el mismo par de números
a = 17
b = 5

print(f"=== CALCULADORA: a = {a}, b = {b} ===")
print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")          # división real
print(f"{a} // {b} = {a // b}")        # cociente entero (hacia abajo)
print(f"{a} % {b} = {a % b}")          # resto, con el signo de b
print(f"{a} ** {b} = {a ** b}")

print("--- Comprobaciones ---")
print("¿a divisible entre b?", a % b == 0)
print("¿a es par?", a % 2 == 0)
print("¿b * (a // b) + a % b == a?", b * (a // b) + a % b == a)   # siempre True
print("¿b distinto de 0 y a / b mayor que 3?", b != 0 and a / b > 3)

Salida

Con a = 17 y b = 5:

=== CALCULADORA: a = 17, b = 5 ===
17 + 5 = 22
17 - 5 = 12
17 * 5 = 85
17 / 5 = 3.4
17 // 5 = 3
17 % 5 = 2
17 ** 5 = 1419857
--- Comprobaciones ---
¿a divisible entre b? False
¿a es par? False
¿b * (a // b) + a % b == a? True
¿b distinto de 0 y a / b mayor que 3? True

Comprobación: 17 // 5 = 3 y 17 % 5 = 2, porque 5 × 3 + 2 = 17. 17 ** 5 = 1419857 (17 × 17 = 289; × 17 = 4913; × 17 = 83521; × 17 = 1419857). 17 no es divisible entre 5 (sobra 2) ni es par (17 % 2 = 1). Y 17 / 5 = 3.4 es mayor que 3.

Con a = 20 y b = 4 (cambiando solo esas dos líneas):

=== CALCULADORA: a = 20, b = 4 ===
20 + 4 = 24
20 - 4 = 16
20 * 4 = 80
20 / 4 = 5.0
20 // 4 = 5
20 % 4 = 0
20 ** 4 = 160000
--- Comprobaciones ---
¿a divisible entre b? True
¿a es par? True
¿b * (a // b) + a % b == a? True
¿b distinto de 0 y a / b mayor que 3? True

Aquí la división es exacta y aun así 20 / 4 da 5.0, un float, mientras que 20 // 4 da 5. El resto es 0, así que 20 es divisible entre 4.

Y con a = -17 y b = 5:

=== CALCULADORA: a = -17, b = 5 ===
-17 + 5 = -12
-17 - 5 = -22
-17 * 5 = -85
-17 / 5 = -3.4
-17 // 5 = -4
-17 % 5 = 3
-17 ** 5 = -1419857
--- Comprobaciones ---
¿a divisible entre b? False
¿a es par? False
¿b * (a // b) + a % b == a? True
¿b distinto de 0 y a / b mayor que 3? False

Esta es la salida que engaña. -17 / 5 es −3.4, pero -17 // 5 es −4, no −3: // redondea hacia abajo, y por debajo de −3,4 el siguiente entero es −4. Y el resto es 3, no −2: es lo que hay que sumarle a 5 × (−4) = −20 para volver a −17. La igualdad sigue dando True, y la última comprobación da False porque −3.4 no es mayor que 3. El dibujo lo enseña en la recta numérica:

Preguntas que te puedes hacer

¿Por qué -17 // 5 no da −3 como en la calculadora del móvil? Porque la calculadora (y int()) cortan los decimales, que es ir hacia el cero, y // redondea hacia abajo, que es ir hacia menos infinito. Con positivos coinciden; con negativos, no. Si necesitas cortar, usa int(a / b).

¿Por qué la línea dice -17 ** 5 = -1419857 si en la teoría -2 ** 2 daba −4? Buena observación. Esa línea es un texto que muestra a y b: el cálculo real es a ** b con a = -17, que es (−17)⁵. Como el exponente es impar, el resultado es negativo y coincide con −(17⁵). Si b fuera 2, a ** b daría 289, pero escribir -17 ** 2 a mano daría −289.

¿Por qué b != 0 and a / b > 3 y no al revés? Por el cortocircuito. Si b fuera 0, b != 0 sería False y el and no llegaría a dividir. Al revés, a / b se calcularía primero y el programa se pararía con ZeroDivisionError.

¿Para qué sirve la igualdad b * (a // b) + a % b == a si siempre da True? Para entender // y % como pareja: el cociente y el resto tienen que reconstruir el número. Si alguna vez un cálculo tuyo de «cuántos caben y cuántos sobran» no la cumple, tienes un error.

Pruébalo tú

• Ejecuta con a = 17 y b = -5. Predice antes el signo de a % b (pista: el resto lleva el signo del divisor).
• Cambia b a 0 y mira qué línea revienta primero. Después piensa cómo usarías and para proteger las divisiones (en el siguiente tema lo harás con if).

Errores típicos en esta práctica

• Olvidar los paréntesis de una fórmula. valor - 32 * 5 / 9 no es la conversión a Celsius. Escribe la fórmula en el orden en que la harías a mano.
• Usar // donde hace falta /. 9 // 5 vale 1 y se lleva por delante el 0,8.
• Calcular dinero con float y comparar con ==. Usa céntimos y, al mostrar, // 100 y % 100 con :02d.
• Dividir el porcentaje antes de multiplicar. 15 // 100 es 0; precio * 15 // 100 es el descuento.
• Olvidarse del resto al repartir. 1091 entre 10 son 109 y sobra 1: si no lo cuentas, pierdes un céntimo.
• Esperar que // corte los decimales con negativos. -17 // 5 es −4; para cortar, int(-17 / 5).

Míralo paso a paso en Python Tutor

Copia este resumen del programa 2 en Python Tutor, elige Python 3 y avanza línea a línea:

total_cent = 1091

euros = total_cent // 100          # 10
centimos = total_cent % 100        # 91
texto = f"{euros},{centimos:02d} €"

por_cafe = total_cent // 10        # 109
sobra = total_cent % 10            # 1
cuadra = por_cafe * 10 + sobra == total_cent

con_floats = 12.00 * 0.85 * 1.07
igual = con_floats == total_cent / 100

print(texto, por_cafe, sobra, cuadra, igual)

Salida:

10,91 € 109 1 True False

Qué observar paso a paso:

1. euros aparece con 10 y centimos con 91: son el cociente y el resto de 1091 entre 100, y los dos son int.
2. En texto verás '10,91 €': el :02d no cambia nada aquí, pero si cambias total_cent a 1005 verás '10,05 €' en lugar de '10,5 €'.
3. por_cafe vale 109 y sobra vale 1; cuadra es True porque 109 × 10 + 1 = 1091.
4. con_floats aparece como 10.914: la cuenta con decimales arrastra el 0,4 del impuesto. Por eso igual es False.

Resumen

• Las fórmulas se escriben pensando en la precedencia: si una suma o resta va primero, necesita paréntesis.
• / para medias, porcentajes y conversiones; // y % para repartir y para separar euros y céntimos.
• El dinero, en céntimos enteros; round solo en el paso que lo pide (el impuesto) y :02d para mostrar dos cifras.
• b * (a // b) + a % b == a se cumple siempre: es la forma de comprobar un reparto.
• Con negativos, // redondea hacia abajo (−17 // 5 = −4) y el resto lleva el signo del divisor.
• La comprobación que protege va delante en un and (b != 0 and a / b > 3).

Checklist: ¿lo has practicado?

• ¿Has ejecutado los tres programas y comprobado las salidas?
• ¿Sabrías explicar por qué valor - 32 * 5 / 9 da 82.22?
• ¿Puedes pasar 1091 céntimos a 10,91 € sin mirar el código?
• ¿Sabes qué dan -17 // 5 y -17 % 5, y por qué?
• ¿Has intentado los «Pruébalo tú» sin mirar la teoría?

Si has respondido que sí a casi todo, estás listo para los ejercicios de operadores en Python, donde ya no te doy el código hecho: la cuota del gimnasio, segundos a horas y el cambio de la caja moneda a moneda. Y después, los condicionales, donde estas comparaciones decidirán qué camino sigue tu programa. ¡Nos vemos allí!

Siguiente paso: ejerciciosOperadores en Python — ejercicios con la cuota del gimnasio, segundos a horas y el cambio de la caja moneda a moneda (y un or que siempre decía que sí)

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →