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.
En una línea
Sección titulada «En una línea»float es rápido y aproximado; Decimal es exacto y ocho veces más lento; Fraction, exacto y ochenta.
Los cuatro contratos
Sección titulada «Los cuatro contratos»| 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 |
int no tiene techo
Sección titulada «int no tiene techo»2 ** 1000 # 302 dígitos, sin desbordar2 ** 1000 * 3 # 576 nsEn 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.
float es una fracción binaria
Sección titulada «float es una fracción binaria»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:
| 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:
s = 0.0for x in [0.1] * 1_000_000: s += xsum([0.1] * 1_000_000)# 100000.0Desde 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.
Lo que cuesta la exactitud
Sección titulada «Lo que cuesta la exactitud»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.
bool es un int
Sección titulada «bool es un int»True y False son enteros con una capa de presentación:
True + True # 2sum([True, False, True]) # 2 ← cuenta aciertos sin bucleisinstance(True, int) # TrueEso 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.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- En bucles numéricos de simulación, gráficos o machine learning:
numpyyfloatson 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.
Ejercicio
Sección titulada «Ejercicio»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.
Comprobación: diez sumas de 0,10 en float, en céntimos enteros y en Decimal.
from decimal import Decimal
total = 0.0for _ in range(10): total += 0.1print("float:", total == 1.0)print("centimos:", sum([10] * 10) == 100, f"{sum([10] * 10) / 100:.2f}")print("Decimal:", sum([Decimal("0.10")] * 10) == Decimal("1.00"))Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 01 · Todo es un objeto: por qué un
intde 30 bits pesa 28 bytes. - 04 · Mutabilidad: los números son inmutables, y eso los hace hashables.
- 09 · Hashabilidad: por qué
1,1.0yTrueson la misma clave.