Saltearse al contenido

Números

Python no tiene «un tipo número». Tiene cuatro, con contratos incompatibles: int es exacto y no tiene límite, float es rápido y aproximado, Decimal es exacto y lento, y Fraction es exacto y más lento todavía. Elegir mal no produce un error: produce un resultado que parece correcto hasta que alguien cuadra las cuentas.

float es rápido y aproximado; Decimal es exacto y ocho veces más lento; Fraction, exacto y ochenta.

Tipo Exacto Límite Sirve para
int Sí Ninguno (memoria) Conteos, dinero en céntimos, IDs
float No (53 bits) ~1.8e308 Física, gráficos, estadística
Decimal Sí (base 10) Configurable Dinero, facturación, tipos de cambio
Fraction Sí (racional) Memoria Probabilidades, ratios exactos
2 ** 1000 # 302 dígitos, sin desbordar
2 ** 1000 * 3 # 576 ns

En C, 2 ** 1000 desborda. En Python, el entero crece: cada 30 bits añade un dígito interno, y la operación cuesta proporcionalmente a su tamaño. La consecuencia práctica es que no hay que elegir entre int y long, y la consecuencia oculta es que un acumulador que crece sin control se vuelve lento antes de volverse imposible.

Un float guarda un número en 64 bits: 1 de signo, 11 de exponente y 52 de mantisa. Eso significa que representa exactamente fracciones cuyo denominador es potencia de dos. 0.1 no lo es:

La suma que no da
Expresión Resultado
0.1 + 0.2 0.30000000000000004
0.1 + 0.2 == 0.3 False
Decimal("0.1") + Decimal("0.2") == Decimal("0.3") True
Fraction(1, 3) * 3 == 1 True

verificado en CPython 3.13

No es un bug de Python: es el estándar IEEE-754, y lo comparten C, Java, JavaScript y casi todo. Lo que sí cambió es cómo se suman:

100000.00000133288
s = 0.0
for x in [0.1] * 1_000_000:
s += x
sum([0.1] * 1_000_000)
# 100000.0

Desde Python 3.12, sum() usa suma compensada de Neumaier para float: lleva la cuenta del error de redondeo y lo corrige. Tu bucle no. Es un cambio que casi ningún libro anterior a 2023 menciona, y una razón para preferir sum() y math.fsum() sobre el acumulador manual.

Sumar 100 000 veces 0,1 según el tipo
float 7.2 ns/elemento Decimal 56.0 ns/elemento Fraction 571.3 ns/elemento

Ocho veces y ochenta veces. La exactitud se paga por operación, no por dato: en un bucle de millones, un Decimal por fila cambia el tiempo de un informe.

La regla que se deduce: usa float para medir y Decimal para contar dinero. Si el resultado se va a comparar con otro, se va a sumar muchas veces o se va a auditar, float es el tipo equivocado. Si el resultado alimenta un gráfico o una simulación física, Decimal es dinero tirado.

True y False son enteros con una capa de presentación:

True + True # 2
sum([True, False, True]) # 2 ← cuenta aciertos sin bucle
isinstance(True, int) # True

Eso permite escribir sum(condicion(x) for x in datos) para contar cuántos cumplen algo, que es más rápido y más corto que un contador manual. Pero también permite comparar con == y equivocarse: x == True acepta 1, porque 1 == True. Para comprobar un booleano, usa if x: o if x is True: según lo que quieras decir, y recuerda que 1 y True son la misma clave en un diccionario.

  • En bucles numéricos de simulación, gráficos o machine learning: numpy y float son el orden de magnitud correcto.
  • Para almacenar dinero en una base de datos: guarda céntimos como int. Es más rápido, no tiene problemas de redondeo y no depende de la configuración de precisión del proceso.
  • Cuando el error es irrelevante por diseño: si el resultado se redondea a dos decimales al final, arrastrar 50 decimales de precisión intermedia no aporta nada medible.

Una tienda calcula el total de un carrito con float y a veces cuadra con un céntimo de diferencia. Explica por qué y propón dos soluciones distintas.

Solución

Porque 0.1 + 0.2 no es 0.3 y los precios con IVA acumulan ese error en cada suma. El céntimo aparece cuando el total se redondea a dos decimales y el error cruza el umbral.

Solución 1 — céntimos como enteros. Guardar 1099 en lugar de 10.99. Se suma exacto y se formatea al mostrar: f"{total / 100:.2f}". Es la opción de bases de datos y la más rápida.

Solución 2 — Decimal de punta a punta. Precios construidos con Decimal("10.99"), suma exacta y redondeo explícito al final con quantize. Más lento, pero el tipo documenta la intención y evita que alguien meta un float por descuido.

Lo que no funciona es sumar en float y redondear al final «para arreglarlo»: el error ya está dentro y el redondeo no sabe de dónde viene.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 1 y 4.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Receta 1.1: Choosing between float, decimal, and fraction.
  • CPython 3.12+: suma compensada en builtin_sum (Python/bltinmodule.c).
  • Mediciones: mediciones/01-06-09-argumentos-numeros-texto-hash.py.
  • 01 · Todo es un objeto: por qué un int de 30 bits pesa 28 bytes.
  • 04 · Mutabilidad: los números son inmutables, y eso los hace hashables.
  • 09 · Hashabilidad: por qué 1, 1.0 y True son la misma clave.