Python / float() / Convertir valores en números de coma flotante

float() de Python convierte números y cadenas numéricas compatibles en números de coma flotante. Sin argumentos devuelve 0.0, pero no transforma automáticamente una cadena vacía o None en cero. Una conversión correcta no garantiza un valor finito ni la precisión decimal necesaria.

Conversión básica y valor original

float(value) devuelve un resultado sin cambiar el tipo de la variable original. La coma flotante representa cantidades con un número finito de bits y puede aproximar fracciones. Ver un punto decimal no demuestra el tipo ni la exactitud. Consulta la referencia oficial de float().

Los ejemplos completos usan Python 3 y la biblioteca estándar. Guárdalos en UTF-8 como float_example.py y ejecuta python float_example.py o python3, según el entorno. Cada ejemplo posterior puede sustituir el contenido del archivo y ejecutarse de forma independiente.

value = 3
converted = float(value)
print(converted, type(converted).__name__)
print(value, type(value).__name__)
print(float("  -2.5  "))
print(float("1e3"))
print(float())
print(float(True))

Resultado esperado:

3.0 float
3 int
-2.5
1000.0
0.0
1.0

value continúa siendo un entero. Se aceptan espacios alrededor, un signo y notación exponencial como 1e3. True se convierte en 1.0; rechaza los booleanos aparte si tu entrada no los permite.

Formatos, ValueError y TypeError

Las cadenas numéricas habituales usan . como separador decimal. No se interpretan automáticamente separadores de miles, comas decimales ni símbolos monetarios. Una cadena mal formada genera ValueError; un objeto no admitido como None genera TypeError.

for value in ("1,234.5", "2,5", "", None):
    try:
        print(float(value))
    except (ValueError, TypeError) as error:
        print(type(error).__name__)

ValueError
ValueError
ValueError
TypeError

Eliminar comas sin revisar puede convertir el decimal esperado 2,5 en 25. Define primero formato y reglas regionales y normaliza solo conforme a ellas. Decide si una entrada vacía es un error o un dato ausente, sin mezclarla con un cero real.

Por qué 0.1 más 0.2 puede no ser igual a 0.3

La mayoría de los sistemas guarda los floats en formato binario. Algunas fracciones decimales no tienen una representación binaria finita y se aproximan. Es una limitación de representación, no una conversión fallida. El tutorial de coma flotante de Python explica el motivo.

import math
from decimal import Decimal

result = 0.1 + 0.2
print(result)
print(result == 0.3)
print(math.isclose(result, 0.3))
print(Decimal("0.1") + Decimal("0.2"))

0.30000000000000004
False
True
0.3

math.isclose() permite comparar aproximadamente, pero sus tolerancias deben ajustarse a unidades y precisión. Cerca de cero considera también abs_tol. Para requisitos decimales exactos, considera Decimal creado desde la cadena decimal original. Decimal(0.1) parte de un valor binario ya aproximado.

Comprobar NaN, infinito y desbordamiento

float() acepta nan e inf. NaN significa Not a Number e inf representa infinito. Analizar una entrada correctamente no demuestra que sea una medida finita válida. Usa math.isfinite() cuando se requiera un número finito.

import math

for text in ("nan", "inf", "-inf", "2.5"):
    number = float(text)
    print(text, math.isfinite(number))

nan False
inf False
-inf False
2.5 True

Una cadena con exponente enorme puede producir infinito, mientras que convertir un entero gigantesco puede lanzar OverflowError. NaN tampoco es igual a sí mismo: no lo detectes mediante x == float("nan"). Para esa comprobación específica usa math.isnan().

print(float("1e400"))
try:
    print(float(10 ** 400))
except OverflowError:
    print("OverflowError")
print(float("nan") == float("nan"))

inf
OverflowError
False

Aceptar solo números finitos

Combina el tratamiento de errores con una comprobación de finitud. Esta función distingue entradas mal formadas y valores no finitos y solo devuelve un float cuando todo es válido. Los mensajes ingleses del ejemplo pueden adaptarse a tus usuarios.

import math

def finite_number(text):
    try:
        number = float(text)
    except (ValueError, TypeError) as error:
        raise ValueError("not a number") from error
    if not math.isfinite(number):
        raise ValueError("not finite")
    return number

for text in ("2.5", "nan", "abc"):
    try:
        print(finite_number(text))
    except ValueError as error:
        print(error)

2.5
not finite
not a number

La función solo comprueba finitud. Edades, cantidades o proporciones pueden necesitar límites inferiores y superiores o una comprobación de entero. No sustituyas cualquier error por 0.0, porque ocultaría la diferencia entre datos inválidos y un cero auténtico.