Conversión de tipos (casting)

0.1 Motivación

En programación, a menudo necesitas convertir datos de un tipo a otro. Por ejemplo, cuando recibes entrada del usuario (siempre es texto), pero necesitas hacer cálculos matemáticos. O cuando quieres mostrar un número como parte de un mensaje de texto. El casting te permite controlar explícitamente qué tipo de dato estás usando, evitando errores y asegurando que tu código funcione correctamente.

0.2 Intuición

Imagina que tienes diferentes moldes para galletas: uno para círculos (int), uno para estrellas (float), y otro para letras (str). Tienes masa (datos) y puedes usar un molde para darle la forma que necesitas. El casting es como elegir el molde adecuado: int() convierte en entero, float() en decimal, str() en texto. Pero ten cuidado: no todos los moldes funcionan con todos los tipos de masa.

0.3 Modelo mental

Python usa funciones constructoras para crear objetos de tipos específicos:

1. int(): convierte a entero (elimina decimales, requiere texto numérico).
2. float(): convierte a decimal (puede convertir enteros y texto numérico).
3. str(): convierte a texto (funciona con casi cualquier cosa).
4. bool(): convierte a booleano (reglas específicas de verdadero/falso).

El casting es explícito: tú decides cuándo y cómo convertir.

0.4 Desarrollo

# Desde enteros
x = int(1)      # 1
y = int(-5)     # -5

# Desde floats (trunca, no redondea)
z = int(2.8)    # 2 (pierde el .8)
w = int(-3.9)   # -3 (trunca hacia cero)

# Desde strings (solo si representan números enteros)
a = int("10")   # 10
b = int("-5")   # -5

# ❌ Error: no se puede convertir texto no numérico
# c = int("Hola")  # ValueError

# Desde enteros
x = float(1)     # 1.0
y = float(-5)    # -5.0

# Desde floats (no cambia)
z = float(2.8)   # 2.8

# Desde strings numéricos
a = float("3")   # 3.0
b = float("3.14") # 3.14
c = float("-5.5") # -5.5
d = float("1e3") # 1000.0 (notación científica)

# ❌ Error: texto no numérico
# e = float("Hola")  # ValueError

# Desde enteros
x = str(5)       # "5"
y = str(-3)      # "-3"

# Desde floats
z = str(3.14)    # "3.14"
w = str(2.0)     # "2.0"

# Desde booleanos
a = str(True)    # "True"
b = str(False)   # "False"

# Desde None
c = str(None)    # "None"

# Desde estructuras de datos
d = str([1, 2, 3])  # "[1, 2, 3]"
e = str({"a": 1})   # "{'a': 1}"

# Falsy (valores que son False)
print(bool(0))      # False
print(bool(0.0))    # False
print(bool(""))     # False
print(bool([]))     # False
print(bool({}))     # False
print(bool(None))   # False

# Truthy (valores que son True)
print(bool(1))      # True
print(bool(-5))     # True
print(bool("Hola")) # True
print(bool(" "))    # True (texto con espacio)
print(bool([1, 2])) # True
print(bool({"a": 1})) # True

# Entero → Flotante
x = 5
y = float(x)  # 5.0

# Flotante → Entero (trunca)
a = 3.99
b = int(a)    # 3 (pierde decimales)

# String numérico → Entero
edad = "25"
edad_int = int(edad)  # 25

# String numérico → Flotante
precio = "19.99"
precio_float = float(precio)  # 19.99

# Entero → String (para mostrar)
total = 100
mensaje = "El total es: " + str(total)  # "El total es: 100"

# 1. Entrada de usuario (siempre es string)
edad_input = "25"  # Simula input()
edad = int(edad_input)  # Convierte a entero para operaciones
print(edad + 5)  # 30

# 2. Mostrar números en mensajes
total = 42.50
print("El total es: " + str(total))  # "El total es: 42.5"

# 3. Operaciones mixtas
x = "10"
y = "5"
print(int(x) + int(y))  # 15 (convertir antes de sumar)

# 4. Validación de datos
def es_numero(texto):
    try:
        int(texto)
        return True
    except ValueError:
        return False

0.5 Ejemplos

Mínimo — Conversiones básicas:

# Conversiones numéricas
print(int(3.14))   # 3
print(float(5))    # 5.0
print(str(42))     # "42"

Progresivo — Conversiones en operaciones:

# Sin casting (error)
# print("Edad: " + 25)  # TypeError

# Con casting (correcto)
edad = 25
print("Edad: " + str(edad))  # "Edad: 25"

# Mejor aún: f-strings
print(f"Edad: {edad}")  # "Edad: 25"

Real — Sistema de registro de usuario:

# Simulación de entrada (todo es texto)
nombre = "Carlos"
edad_texto = "28"
altura_texto = "1.75"

# Casting para operaciones
edad = int(edad_texto)
altura = float(altura_texto)

# Cálculos
edad_futura = edad + 10
imc = 70 / (altura ** 2)  # Peso fijo de 70kg

# Casting para mostrar
print("=== Registro de Usuario ===")
print("Nombre: " + nombre)
print("Edad: " + str(edad) + " años")
print("Altura: " + str(altura) + " m")
print("Edad en 10 años: " + str(edad_futura))
print(f"IMC estimado: {imc:.2f}")  # F-strings sin casting necesario

0.6 Errores comunes

0.7 Buenas prácticas

1. Siempre convierte entrada de usuario:

   python

   edad = int(input("Edad: "))  # input siempre retorna str

2. Usa f-strings para mostrar datos (evita casting manual):

   python

   # ❌ Menos elegante
   print("Edad: " + str(edad) + " años")
   
   # ✅ Más elegante y legible
   print(f"Edad: {edad} años")

3. Valida antes de convertir:

   python

   valor = input("Número: ")
   if valor.isdigit():  # Solo dígitos
       numero = int(valor)
   else:
       print("No es un número válido")

4. Usa try/except para manejar errores de conversión:

   python

   try:
       edad = int(input("Edad: "))
   except ValueError:
       print("Error: debes ingresar un número")

5. Convierte lo más tarde posible: mantén los datos en su tipo original hasta que necesites otro.

0.8 Ejercicio

Básico — Conversiones de tipos

Escribe un programa que:

1. Cree las siguientes variables:
   • numero_texto = “10”
   • numero_decimal = 3.14
   • texto_numerico = “5.5”
   • valor_booleano = True
2. Realice las siguientes conversiones:
   • Convierta numero_texto a entero
   • Convierta numero_decimal a entero (observa qué pasa)
   • Convierta texto_numerico a float
   • Convierta valor_booleano a entero
3. Muestre los resultados y sus tipos

Solución (no mires hasta haberlo intentado):

# Datos originales
numero_texto = "10"
numero_decimal = 3.14
texto_numerico = "5.5"
valor_booleano = True

# Conversiones
entero_desde_texto = int(numero_texto)
entero_desde_decimal = int(numero_decimal)  # Trunca a 3
float_desde_texto = float(texto_numerico)
entero_desde_booleano = int(valor_booleano)

# Resultados
print("=== Conversiones ===")
print(f"'{numero_texto}' → {entero_desde_texto} ({type(entero_desde_texto)})")
print(f"{numero_decimal} → {entero_desde_decimal} ({type(entero_desde_decimal)})")
print(f"'{texto_numerico}' → {float_desde_texto} ({type(float_desde_texto)})")
print(f"{valor_booleano} → {entero_desde_booleano} ({type(entero_desde_booleano)})")

# Nota: los booleanos son subclase de int en Python
print(f"\n¿True es int? {isinstance(True, int)}")  # True

0.9 Síntesis

• int(): convierte a entero (trunca decimales, requiere números válidos).
• float(): convierte a decimal (funciona con enteros y texto numérico).
• str(): convierte a texto (funciona con casi todo).
• bool(): convierte a booleano (reglas de truthy/falsy).
• F-strings: alternativa moderna a str() para mostrar datos.
• Validación: siempre verifica antes de convertir entrada de usuario.
• Errors comunes: ValueError al convertir texto no numérico.

0.10 Qué sigue

• Relacionado: tipos de datos, formateo de strings, validación de entrada
• Siguiente tema: Strings — aprenderás a trabajar con texto y todas sus operaciones y métodos.