Números y números de punto flotante (float)

Python tiene dos tipos numéricos

Python dispone de dos tipos numéricos principales para trabajar con números: int para números enteros y float (punto flotante) para decimales.

Ambos son números, así que puedes hacer toda la aritmética básica — suma, resta, multiplicación, división y módulo — con cualquiera.

Pero su sintaxis y precisión difieren, así que eliges el adecuado para cada situación.

Aunque el valor parezca un número entero, añadir .0 como 3.0 lo convierte en float. Al contrario, escribir solo 175 lo deja como int.

Los negativos funcionan igual — -5 es int, -5.5 es float.

# int (número entero)
age = 25
print(type(age))      # <class 'int'>

# float (punto flotante)
weight = 175.5
print(type(weight))   # <class 'float'>

# El mismo "3", tipos distintos según cómo se escribe
print(type(3))        # <class 'int'>
print(type(3.0))      # <class 'float'>

# Los negativos funcionan igual
print(type(-10))      # <class 'int'>
print(type(-10.5))    # <class 'float'>

Comprueba la diferencia entre int y float en la terminal.

① Crea count = 7 y pi = 3.14, e imprime ambos valores y tipos con print().

② Escribe print(type(3.0)) para ver con tus propios ojos que 3 y 3.0 tienen tipos distintos.

Repaso rápido de los operadores

Hay 7 operadores que usas para matemáticas numéricas. Las cuatro operaciones básicas + - * / funcionan igual que en otros lenguajes, pero // (división entera), % (módulo) y ** (exponenciación) aparecen mucho en Python, así que vale la pena dominarlos.

/ devuelve float incluso entre ints

10 / 2 es 5.0 (float), no 5.

El / de Python está diseñado para devolver siempre un float, así que el resultado es float incluso cuando ambos operandos son ints.

Si quieres un resultado entero, usa //.

# Aritmética básica
print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30

# La división siempre devuelve float
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0  (sigue siendo float aunque divida exacto)

# División entera (trunca) y módulo
print(10 // 3)   # 3
print(10 % 3)    # 1

# Exponenciación: a ** b significa «a elevado a b»
print(2 ** 10)   # 1024
print(3 ** 2)    # 9
print(2 ** 0.5)  # 1.4142135623730951  (se puede usar como raíz cuadrada)

Veamos cuántos minutos y segundos son seconds = 365.

① Usa // para imprimir «cuántos minutos».

② Usa % para imprimir «cuántos segundos sobrantes».

③ Usa `** para imprimir 2 elevado a la 8 (256).

④ Imprime 10 / 2 y confirma que el resultado es un float (5.0) incluso cuando la división es exacta.

Operadores de asignación compuesta (+= / -= etc.)

Los patrones del tipo «x = x + 1» — donde haces algo a una variable y guardas el resultado en ella misma — aparecen a menudo.

Puedes acortarlo a «x += 1», y estas formas abreviadas se llaman operadores de asignación compuesta.

Cada uno de `+ - / // % * tiene una forma compuesta.

score = 10

score += 5      # 10 + 5 -> 15
print(score)    # 15

score *= 2      # 15 * 2 -> 30
print(score)    # 30

score -= 7      # 30 - 7 -> 23
print(score)    # 23

# Funciona igual con float
weight = 60.0
weight += 1.5
print(weight)   # 61.5

Actualicemos los PV de un personaje partiendo de hp = 100, usando asignación compuesta.

① Disminuye hp en 30 e imprímelo.

② Luego duplica hp e imprímelo.

③ Luego reemplaza hp por el resto de hp dividido entre 5, e imprímelo.

Mezclar int y float en operaciones

Cuando mezclas int y float, el resultado siempre es float. Es porque Python promueve automáticamente al tipo de mayor precisión.

Como se mencionó antes, / (división) devuelve float incluso entre ints, mientras que // (división entera) devuelve int cuando ambos operandos son ints.

# int con int sigue siendo int
print(10 + 3)        # 13   -> int
print(type(10 + 3))  # <class 'int'>

# Si algún lado es float, el resultado es float
print(10 + 3.0)         # 13.0
print(type(10 + 3.0))   # <class 'float'>

# / devuelve float incluso entre ints
print(10 / 2)           # 5.0
print(type(10 / 2))     # <class 'float'>

# // sigue siendo int cuando ambos son int
print(10 // 3)          # 3
print(type(10 // 3))    # <class 'int'>

# // pasa a float si algún lado es float
print(10 // 3.0)        # 3.0
print(type(10 // 3.0))  # <class 'float'>

Intenta predecir el tipo del resultado y luego compruébalo.

① Imprime el resultado y tipo de 7 + 2.

② Imprime el resultado y tipo de 7 + 2.0.

③ Imprime el resultado y tipo de 10 / 5 (fíjate en que es float aunque la división sea exacta).

float tiene precisión limitada

Las computadoras almacenan los float como una aproximación binaria. Por eso, incluso cálculos que parecen simples pueden producir un pequeño error.

El ejemplo de abajo es un clásico «gotcha de float» — todo principiante se topa con él en algún momento.

Veamos el error con tus propios ojos.

① Imprime 0.1 + 0.2 (confirma que no da 0.3).

② Imprime 0.1 + 0.1 + 0.1.

③ Imprime 0.1 + 0.2 == 0.3 (no será True).

Usa Decimal cuando necesites matemáticas exactas

En situaciones donde incluso un pequeño error es inaceptable — como los cálculos monetarios — puedes hacer aritmética decimal exacta con el tipo Decimal de la biblioteca estándar. No lo cubriremos en este artículo, pero recuerda: «float es una aproximación» y «hay otra herramienta para matemáticas exactas».

Cambiar de tipo con int() y float()

Para convertir entre tipos numéricos, usa las funciones integradas int() y float().

Ojo con una cosa: int() trunca la parte decimal — no redondea. Así que pasar 3.9 a int() te da 3, no 4. En los negativos, redondea hacia cero, así que -3.9 se vuelve -3, no -4.

# float -> int es «truncar» (¡NO redondear!)
print(int(3.9))     # 3
print(int(3.1))     # 3
print(int(-3.9))    # -3   (redondea hacia cero)

# int -> float solo añade .0
print(float(5))     # 5.0
print(float(-2))    # -2.0

# Usar la conversión a través de una variable
a = 3.9
a = int(a)
print(a, type(a))       # 3 <class 'int'>

b = 5
b = float(b)
print(b, type(b))       # 5.0 <class 'float'>

Comprobemos cómo se comporta int().

① Imprime el resultado de int(7.8) (no redondea).

② Imprime el resultado de int(-7.8) (mira hacia dónde redondea en el lado negativo).

③ Imprime el resultado y tipo de float(10).

En este artículo aprendiste:

• La diferencia entre int y float
• Exponenciación con «**» y asignación compuesta (+= y compañía)
• La diferencia de tipo de retorno entre «/» (división) y «//» (división entera)
• Los problemas de precisión de float
• La conversión de tipos con int() / float()