Pensamiento Computacional · 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.
Escribir una función que reciba una cantidad de segundos y devuelva un string con el formato "h:mm:ss", con los minutos y los segundos siempre en dos dígitos. Con 3725 tiene que devolver "1:02:05".
El ejercicio tiene dos partes independientes: descomponer el número, y darle formato. Conviene resolverlas por separado.
La descomposición. Cada unidad sale de una división entera y cada resto alimenta la siguiente:
minutos = (s % 3600) // 60 ← el resto de las horas, en minutos
segundos = s % 60
Con 3725, paso a paso:
3725 % 3600 = 125 → sobran 125 segundos
125 // 60 = 2 → 2 minutos
3725 % 60 = 5 → 5 segundos
Ojo con los segundos: se calculan con s % 60 sobre el número original, no sobre el resto anterior. Las dos formas dan lo mismo acá, porque 3600 es múltiplo de 60, pero conviene hacerlo directo para no depender de eso.
El formato, que es la mitad del ejercicio. Si se escribe sin formatear, 3725 devuelve "1:2:5" y eso no es lo pedido. format(n, "02d") rellena con ceros a la izquierda hasta dos dígitos:
format(59, "02d") → "59" (no agrega nada si ya tiene dos)
Las horas van sin relleno, porque el enunciado pide "h" y no "hh": con 3725 la salida empieza con 1, no con 01.
La función completa:
h = s // 3600
m = (s % 3600) // 60
seg = s % 60
return str(h) + ":" + format(m, "02d") + ":" + format(seg, "02d")
Las pruebas, elegidas para cubrir los casos raros:
reloj(59) → "0:00:59" menos de un minuto
reloj(7200) → "2:00:00" exacto, sin resto
reloj(0) → "0:00:00" el borde
reloj(86399) → "23:59:59" un segundo antes de un día
El control inverso, que es el mejor que hay: se reconstruye el número desde la respuesta.
Si no vuelve el número original, la descomposición está mal, y ese control se puede hacer con cualquier entrada sin saber de antemano el resultado esperado.
La versión más corta, con divmod, que devuelve cociente y resto de una:
h, resto = divmod(s, 3600)
m, seg = divmod(resto, 60)
return f"{h}:{m:02d}:{seg:02d}"
Dónde se pierde el punto: devolver los tres números por separado en vez de un string, o armar el string con str(m) pelado. El enunciado pide dos dígitos: sin el 02d, "1:2:5" es una respuesta incorrecta aunque los números estén bien.
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: 8 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é. Y uno para escribir el programa vos, que se prueba ejecutándolo en Python ahí mismo, en el navegador. Además trae una animación que muestra la idea en movimiento.
Practicar Operadores numéricos →Dónde entra este tema en el parcial
- Primer parcial — Trazar: texto, división entera y rebanadas10 puntos · resuelto paso a paso
- Primer parcial — Encontrar los errores y explicarlos30 puntos · resuelto paso a paso
Los otros temas de la unidad 2
Datos, expresiones y funciones