Pensamiento Computacional (090) · Unidad 2 — Datos, expresiones y funciones
Operadores numéricos
Python tiene dos divisiones y un resto. Confundirlas es el error que más puntos cuesta, y con negativos se pone raro.
La explicación
Los siete operadores
- resta 7 - 2 → 5
* multiplicación 7 * 2 → 14
/ división 7 / 2 → 3.5
// división entera 7 // 2 → 3
% resto 7 % 2 → 1
** potencia 7 ** 2 → 49
Las dos divisiones
/ siempre da float, aunque la división sea exacta: 4 / 2 da
2.0, no 2.// se queda con la parte entera del resultado.% da lo que sobra.Y los dos últimos van juntos: 7 = 2 × 3 + 1, donde el 3 es
7//2
y el 1 es 7%2. Si te olvidás cuál es cuál, reconstruí la cuenta de dividir de la escuela.
Para qué sirve el resto
- Par o impar:
n % 2 == 0es la forma estándar de preguntar si es par. - Múltiplo de algo:
n % 5 == 0. - Último dígito:
n % 10. - Dar la vuelta: con 12 horas,
(hora + 5) % 12.
Con negativos se pone raro — y entra
-7 % 3 → 2 (no -1)
Python redondea hacia abajo, no hacia cero: -3,5 baja a -4. Y el resto queda con el signo
del divisor, por eso -7 % 3 da 2. Otros lenguajes hacen lo contrario, así que no
alcanza con la intuición: hay que saber que Python es así.
Ojo con la diferencia: int(-3.5) da -3 porque trunca hacia cero,
pero -7 // 2 da -4 porque redondea hacia abajo. No son la misma operación.
Precedencia
Como en matemática. Ante la duda, paréntesis: no cuestan nada y se lee mejor.
Operar y guardar en el mismo paso
Cuando el nuevo valor de una variable se calcula a partir del que ya tenía, se escribe corto:
x -= 3 x = x - 3
x *= 2 x = x * 2
x //= 2 x = x // 2
Arrancando de x = 10 y haciendo += 5, *= 2, -= 3 y //= 2 en ese orden, x termina valiendo 13. Es la forma normal de escribir contadores y acumuladores, así que conviene acostumbrarse desde ahora: aparece en cada ciclo del resto de la materia.
Los decimales mienten un poquito
0.30000000000000004
No es un error de Python: los float se guardan en binario y 0,1 no tiene representación exacta en binario, igual que 1/3 no la tiene en decimal. La consecuencia práctica es una sola y hay que recordarla: no compares dos flotantes con ==.
0.1 + 0.2 == 0.3 devuelve False y arruina un if que parecía obvio. Las dos salidas: redondear antes de comparar, round(0.1 + 0.2, 2) == 0.3, o preguntar si la diferencia es despreciable, abs(0.1 + 0.2 - 0.3) < 1e-9. Las dos dan True. Entre enteros el problema no existe: == entre int es exacto siempre.
Un programa recibe una cantidad de minutos y tiene que mostrarla como horas y minutos. Con 200 minutos debería decir "3 h 20 min".
Qué operación va de cada lado. Las horas son cuántas veces entra 60 completo: eso es división entera. Los minutos que sobran son el resto.
horas = total // 60
minutos = total % 60
print(horas, "h", minutos, "min")
Las cuentas:
200 % 60 = 20 (porque 3 × 60 = 180, y 200 − 180 = 20)
Salida: 3 h 20 min
/ en vez de //, horas valdría
3.3333... y la salida sería 3.3333333333333335 h 20 min. Ese decimal
largo delatando un / mal puesto es de lo que más se ve.
El control que siempre cierra: horas × 60 + minutos tiene que dar el total.
Acá 3 × 60 + 20 = 200 ✓
horas = total // 60 → 4
minutos = total % 60 → 5
+= es el mismo que vas a escribir adentro de todos
los ciclos de la unidad 3, sumando de a un elemento por vuelta.
Por qué este ejercicio nunca da problemas de decimales: todo lo que interviene es
int, y entre enteros las cuentas son exactas. Si el enunciado hubiera hablado de
precios con centavos habría que tener cuidado con ==, por lo que pasa con los
float. Un truco de oficio para plata: trabajar en centavos, con enteros, y dividir
recién al mostrar.
Dónde se cae la mayoría
- Usar / cuando se necesita //, y que aparezca un .0 donde tenía que haber un entero.
- Con negativos, suponer que // trunca: -7 // 2 da -4, no -3.
- Confundir cociente con resto. El resto es lo que sobra, no el resultado de dividir.
Hasta acá la explicación. La práctica es la otra mitad: 7 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Además trae una animación que muestra la idea en movimiento.
Practicar Operadores numéricos →