Conversión de Tipos y Formateo de Strings

¿Alguna vez has necesitado cambiar el contenido de una caja azul (números enteros) a una caja amarilla (texto)? ¿O transformar el contenido de una caja amarilla en una caja verde (decimales)? ¡En Python esto es posible y muy útil!

La conversión de tipos es como tener una máquina mágica que puede transformar el contenido de un tipo de caja a otro.

🌟 Tres formas de combinar texto y variables

💭 Nota del autor: En mi experiencia enseñando Python, he notado que muchos principiantes se confunden con las diferentes formas de combinar texto y variables. Permíteme mostrarte las tres formas principales, en orden de preferencia.

1. F-strings (Recomendado - Python 3.6+)

Los f-strings son la forma más moderna, legible y eficiente de combinar texto y variables en Python:

nombre = "Ana"
edad = 25
salario = 1500.50

# F-string (prefijo f antes de las comillas)
mensaje = f"Hola {nombre}, tienes {edad} años y ganas ${salario:.2f}"
print(mensaje)  # Hola Ana, tienes 25 años y ganas $1500.50

2. Concatenación (Fallback - Universal)

La concatenación es la forma más básica y funciona en todas las versiones de Python:

nombre = "Ana"
edad = 25
salario = 1500.50

# Concatenación (usando el operador +)
mensaje = "Hola " + nombre + ", tienes " + str(edad) + " años y ganas $" + str(salario)
print(mensaje)  # Hola Ana, tienes 25 años y ganas $1500.5

3. Format() (Legacy - Código Antiguo)

El método format() fue popular antes de los f-strings:

nombre = "Ana"
edad = 25
salario = 1500.50

# Método format()
mensaje = "Hola {}, tienes {} años y ganas ${:.2f}".format(nombre, edad, salario)
print(mensaje)  # Hola Ana, tienes 25 años y ganas $1500.50

🎯 Mi recomendación personal

💭 Nota del autor: Después de años programando en Python, siempre recomiendo usar f-strings cuando sea posible. Son más legibles, más rápidos y hacen que tu código sea más mantenible. Solo usa concatenación para casos muy simples o cuando necesites compatibilidad con versiones antiguas de Python.

¿Qué es la conversión de tipos?

Imagínate que tienes una máquina transformadora en tu almacén. Puedes meter una caja azul con el número 25 y la máquina te devuelve una caja amarilla con el texto "25". ¡El contenido se ve igual, pero ahora es de un tipo diferente!

# Caja azul original
numero = 25
print("Contenido:", numero)
print("Tipo de caja:", type(numero))  # <class 'int'>

# Transformar a caja amarilla
numero_como_texto = str(numero)
print("Contenido transformado:", numero_como_texto)
print("Nuevo tipo de caja:", type(numero_como_texto))  # <class 'str'>

Las máquinas transformadoras de Python

Python tiene varias máquinas transformadoras:

🔄 `str()` - Transformadora a Caja Amarilla

Convierte cualquier cosa a texto:

# De caja azul a caja amarilla
edad = 25
edad_texto = str(edad)
print("Edad como texto:", edad_texto)  # "25"

# De caja verde a caja amarilla
precio = 19.99
precio_texto = str(precio)
print("Precio como texto:", precio_texto)  # "19.99"

# De caja roja a caja amarilla
es_estudiante = True
estudiante_texto = str(es_estudiante)
print("Estado como texto:", estudiante_texto)  # "True"

🔄 `int()` - Transformadora a Caja Azul

Convierte a números enteros:

# De caja amarilla a caja azul
edad_texto = "25"
edad_numero = int(edad_texto)
print("Edad como número:", edad_numero)  # 25

# De caja verde a caja azul (¡cuidado, pierde decimales!)
precio = 19.99
precio_entero = int(precio)
print("Precio sin decimales:", precio_entero)  # 19 (se trunca)

# De caja roja a caja azul
es_verdadero = True
verdadero_numero = int(es_verdadero)
print("True como número:", verdadero_numero)  # 1

es_falso = False
falso_numero = int(es_falso)
print("False como número:", falso_numero)  # 0

🔄 `float()` - Transformadora a Caja Verde

Convierte a números decimales:

# De caja amarilla a caja verde
precio_texto = "19.99"
precio_decimal = float(precio_texto)
print("Precio como decimal:", precio_decimal)  # 19.99

# De caja azul a caja verde
edad = 25
edad_decimal = float(edad)
print("Edad como decimal:", edad_decimal)  # 25.0

# De caja roja a caja verde
es_verdadero = True
verdadero_decimal = float(es_verdadero)
print("True como decimal:", verdadero_decimal)  # 1.0

🔄 `bool()` - Transformadora a Caja Roja

Convierte a verdadero/falso:

# De caja azul a caja roja
numero_positivo = 5
es_verdadero = bool(numero_positivo)
print("5 como booleano:", es_verdadero)  # True

numero_cero = 0
es_falso = bool(numero_cero)
print("0 como booleano:", es_falso)  # False

# De caja amarilla a caja roja
texto_lleno = "Hola"
texto_verdadero = bool(texto_lleno)
print("'Hola' como booleano:", texto_verdadero)  # True

texto_vacio = ""
texto_falso = bool(texto_vacio)
print("'' como booleano:", texto_falso)  # False

Ejemplo práctico: Calculadora de edad

Vamos a crear un programa que demuestre la conversión de tipos y las diferentes formas de combinar texto con variables:

# ================================
# CALCULADORA DE EDAD
# ================================

print("=== CALCULADORA DE EDAD ===")
print()

# El usuario ingresa su año de nacimiento como texto
print("Por favor, ingresa tu año de nacimiento:")
año_nacimiento_texto = "1995"  # Simular entrada del usuario
print("Entrada del usuario:", año_nacimiento_texto)
print("Tipo de caja:", type(año_nacimiento_texto))  # str
print()

# Transformar de caja amarilla a caja azul para hacer cálculos
print("🔄 Transformando texto a número...")
año_nacimiento = int(año_nacimiento_texto)
print("Año como número:", año_nacimiento)
print("Tipo de caja:", type(año_nacimiento))  # int
print()

# Calcular edad (usando caja azul para el año actual)
año_actual = 2024
edad = año_actual - año_nacimiento
print("Cálculo: ", año_actual, "-", año_nacimiento, "=", edad)
print()

# ================================
# FORMAS DE COMBINAR TEXTO Y VARIABLES
# ================================

print("🔄 Creando mensajes con diferentes métodos...")
print()

# 🌟 MÉTODO 1: F-STRINGS (RECOMENDADO - MODERNO Y FÁCIL)
print("🌟 Método 1: F-strings (Recomendado)")
mensaje_fstring = f"Tienes {edad} años"
print("Resultado:", mensaje_fstring)
print("Código:", 'f"Tienes {edad} años"')
print()

# 🔧 MÉTODO 2: CONCATENACIÓN (FALLBACK - SIMPLE Y UNIVERSAL)
print("🔧 Método 2: Concatenación (Fallback)")
edad_texto = str(edad)
mensaje_concatenacion = "Tienes " + edad_texto + " años"
print("Resultado:", mensaje_concatenacion)
print("Código:", '"Tienes " + str(edad) + " años"')
print()

# 📚 MÉTODO 3: FORMAT() (LEGACY - MÉTODO ANTERIOR)
print("📚 Método 3: format() (Legacy)")
mensaje_format = "Tienes {} años".format(edad)
print("Resultado:", mensaje_format)
print("Código:", '"Tienes {} años".format(edad)')
print()

# Verificar si es mayor de edad (transformar a booleano)
print("🔄 Verificando mayoría de edad...")
es_mayor_edad = edad >= 18
print("¿Es mayor de edad?", es_mayor_edad)
print("Tipo de caja:", type(es_mayor_edad))  # bool

Conversiones automáticas vs manuales

Conversiones automáticas (Python las hace solo):

# Python convierte automáticamente en operaciones mixtas
numero_entero = 5
numero_decimal = 2.5
resultado = numero_entero + numero_decimal  # 5 se convierte a 5.0
print("Resultado:", resultado)  # 7.5
print("Tipo:", type(resultado))  # float

Conversiones manuales (tú las haces):

# Tú decides cuándo y cómo convertir
edad_texto = "25"
edad_numero = int(edad_texto)  # Conversión manual
print("Edad:", edad_numero)

Errores comunes en conversiones

1. Intentar convertir texto no numérico a número

# ❌ ERROR
nombre = "Ana"
# numero = int(nombre)  # ValueError: invalid literal for int()

# ✅ CORRECTO - verificar antes
texto = "123"
if texto.isdigit():
    numero = int(texto)
    print("Conversión exitosa:", numero)
else:
    print("No se puede convertir a número")

2. Perder información en conversiones

# ❌ CUIDADO - se pierden decimales
precio = 19.99
precio_entero = int(precio)
print("Precio original:", precio)      # 19.99
print("Precio convertido:", precio_entero)  # 19 (se perdió .99)

# ✅ MEJOR - usar round() si quieres redondear
precio_redondeado = round(precio)
print("Precio redondeado:", precio_redondeado)  # 20

3. Confundir tipos en operaciones

# ❌ ERROR - no puedes sumar texto con números
edad = 25
# mensaje = "Tengo " + edad + " años"  # TypeError

# ✅ CORRECTO - convertir a texto primero
mensaje = "Tengo " + str(edad) + " años"
print(mensaje)  # "Tengo 25 años"

Ejemplo práctico: Sistema de calificaciones

# ================================
# SISTEMA DE CALIFICACIONES
# ================================

print("=== SISTEMA DE CALIFICACIONES ===")
print()

# Calificaciones ingresadas como texto (simulando entrada de usuario)
calificacion1_texto = "85"
calificacion2_texto = "92"
calificacion3_texto = "78"
nombre_estudiante = "María González"

print("📝 Calificaciones ingresadas:")
# 🌟 Usando f-strings para mostrar información
print(f"Estudiante: {nombre_estudiante}")
print(f"Materia 1: {calificacion1_texto}")
print(f"Materia 2: {calificacion2_texto}")
print(f"Materia 3: {calificacion3_texto}")
print(f"Tipo de datos: {type(calificacion1_texto)}")
print()

# Convertir de texto a números para hacer cálculos
print("🔄 Convirtiendo calificaciones a números...")
cal1 = int(calificacion1_texto)
cal2 = int(calificacion2_texto)
cal3 = int(calificacion3_texto)

# 🌟 F-strings para mostrar conversiones
print(f"Calificación 1: {cal1} - Tipo: {type(cal1)}")
print(f"Calificación 2: {cal2} - Tipo: {type(cal2)}")
print(f"Calificación 3: {cal3} - Tipo: {type(cal3)}")
print()

# Calcular promedio (resultado será decimal)
print("📊 Calculando promedio...")
suma = cal1 + cal2 + cal3
promedio = suma / 3

# 🌟 F-strings con formateo de números
print(f"Suma: {suma}")
print(f"Promedio: {promedio:.2f}")
print(f"Tipo del promedio: {type(promedio)}")
print()

# Redondear promedio
promedio_redondeado = round(promedio, 2)
print(f"Promedio redondeado: {promedio_redondeado}")
print()

# Determinar si aprobó (convertir a booleano)
print("✅ Verificando aprobación...")
aprobo = promedio >= 70
print(f"¿Aprobó? (promedio >= 70): {aprobo}")
print(f"Tipo: {type(aprobo)}")
print()

# Crear mensaje final con los tres métodos
print("📄 Generando reporte final con diferentes métodos...")
print()

estado_texto = "APROBADO" if aprobo else "REPROBADO"

# 🌟 F-string (recomendado)
reporte_fstring = f"Estudiante: {nombre_estudiante} | Promedio: {promedio_redondeado} | Estado: {estado_texto}"
print("🌟 Con f-string:")
print(f"   {reporte_fstring}")
print()

# 🔧 Concatenación (fallback)
promedio_texto = str(promedio_redondeado)
reporte_concat = ("Estudiante: " + nombre_estudiante + " | Promedio: " + 
                 promedio_texto + " | Estado: " + estado_texto)
print("🔧 Con concatenación:")
print(f"   {reporte_concat}")
print()

# 📚 Format (legacy)
reporte_format = "Estudiante: {} | Promedio: {} | Estado: {}".format(
    nombre_estudiante, promedio_redondeado, estado_texto
)
print("📚 Con format:")
print(f"   {reporte_format}")
print()

# Reporte detallado con f-strings
print("📋 REPORTE DETALLADO (con f-strings):")
print("=" * 50)
print(f"👤 Estudiante: {nombre_estudiante}")
print(f"📊 Calificaciones individuales:")
print(f"   • Materia 1: {cal1}/100")
print(f"   • Materia 2: {cal2}/100") 
print(f"   • Materia 3: {cal3}/100")
print(f"📈 Estadísticas:")
print(f"   • Suma total: {suma} puntos")
print(f"   • Promedio: {promedio:.2f}/100")
print(f"   • Estado: {estado_texto}")
print(f"   • Puntos para aprobar: {70 - promedio:.1f}" if not aprobo else f"   • Puntos sobre el mínimo: {promedio - 70:.1f}")

Conversiones útiles en la vida real

1. Entrada de usuario (siempre texto)

# Simular entrada de usuario
nombre = "Ana"  # input() siempre devuelve texto
edad_texto = "25"  # input() siempre devuelve texto

# Convertir edad para cálculos
edad = int(edad_texto)
año_nacimiento = 2024 - edad

# 🌟 F-string (recomendado)
mensaje_fstring = f"Hola {nombre}, naciste aproximadamente en {año_nacimiento}"
print("Con f-string:", mensaje_fstring)

# 🔧 Concatenación (fallback)
mensaje_concat = "Hola " + nombre + ", naciste aproximadamente en " + str(año_nacimiento)
print("Con concatenación:", mensaje_concat)

# 📚 Format (legacy)
mensaje_format = "Hola {}, naciste aproximadamente en {}".format(nombre, año_nacimiento)
print("Con format:", mensaje_format)

2. Formateo de números para mostrar

# Cálculos con decimales
precio_base = 100
descuento = 0.15
precio_final = precio_base * (1 - descuento)

# 🌟 F-string (recomendado) - con formateo automático
mensaje_fstring = f"El precio final es: ${precio_final:.2f}"
print("Con f-string:", mensaje_fstring)

# 🔧 Concatenación (fallback) - necesita conversión manual
precio_texto = str(round(precio_final, 2))
mensaje_concat = "El precio final es: $" + precio_texto
print("Con concatenación:", mensaje_concat)

# 📚 Format (legacy)
mensaje_format = "El precio final es: ${:.2f}".format(precio_final)
print("Con format:", mensaje_format)

3. Validaciones con mensajes

# Verificar si un texto puede convertirse a número
entrada_usuario = "123"
nombre_usuario = "Carlos"

if entrada_usuario.isdigit():
    numero = int(entrada_usuario)
    
    # 🌟 F-string (recomendado)
    mensaje_fstring = f"¡Perfecto {nombre_usuario}! '{entrada_usuario}' es un número válido: {numero}"
    print("Con f-string:", mensaje_fstring)
    
    # 🔧 Concatenación (fallback)
    mensaje_concat = ("¡Perfecto " + nombre_usuario + "! '" + entrada_usuario + 
                     "' es un número válido: " + str(numero))
    print("Con concatenación:", mensaje_concat)
    
    # 📚 Format (legacy)
    mensaje_format = "¡Perfecto {}! '{}' es un número válido: {}".format(
        nombre_usuario, entrada_usuario, numero
    )
    print("Con format:", mensaje_format)
else:
    # 🌟 F-string para mensajes de error
    error_fstring = f"Lo siento {nombre_usuario}, '{entrada_usuario}' no es un número válido"
    print("Error con f-string:", error_fstring)

Tabla de conversiones comunes

Desde	Hacia	Función	Ejemplo	Resultado
int	str	`str()`	`str(25)`	`"25"`
int	float	`float()`	`float(25)`	`25.0`
int	bool	`bool()`	`bool(25)`	`True`
float	str	`str()`	`str(19.99)`	`"19.99"`
float	int	`int()`	`int(19.99)`	`19`
float	bool	`bool()`	`bool(19.99)`	`True`
str	int	`int()`	`int("25")`	`25`
str	float	`float()`	`float("19.99")`	`19.99`
str	bool	`bool()`	`bool("Hola")`	`True`
bool	str	`str()`	`str(True)`	`"True"`
bool	int	`int()`	`int(True)`	`1`
bool	float	`float()`	`float(True)`	`1.0`

Ejercicio práctico: Conversor universal

# ================================
# CONVERSOR UNIVERSAL DE TIPOS
# ================================

print("🔄 CONVERSOR UNIVERSAL DE TIPOS")
print("=" * 40)

# Valor original
valor_original = 42
print(f"\n📦 Valor original: {valor_original}")
print(f"   Tipo: {type(valor_original)}")

# Convertir a todos los tipos posibles
print("\n🔄 CONVERSIONES:")

# A texto
valor_str = str(valor_original)
print(f"🟡 Como texto (str): '{valor_str}' - Tipo: {type(valor_str)}")

# A decimal
valor_float = float(valor_original)
print(f"🟢 Como decimal (float): {valor_float} - Tipo: {type(valor_float)}")

# A booleano
valor_bool = bool(valor_original)
print(f"🔴 Como booleano (bool): {valor_bool} - Tipo: {type(valor_bool)}")

print("\n" + "=" * 40)
print("🧪 PROBANDO CON DIFERENTES VALORES:")

# Probar con diferentes valores
valores_prueba = [0, -5, 3.14, "123", "Hola", True, False, ""]

for i, valor in enumerate(valores_prueba, 1):
    print(f"\n📦 Prueba {i}: {repr(valor)} ({type(valor).__name__})")
    
    # Intentar convertir a booleano (siempre funciona)
    print(f"   🔴 bool(): {bool(valor)}")
    
    # Intentar convertir a texto (siempre funciona)
    print(f"   🟡 str(): '{str(valor)}'")
    
    # Intentar convertir a número (puede fallar)
    try:
        if isinstance(valor, str) and valor.replace('.', '').replace('-', '').isdigit():
            if '.' in valor:
                resultado_float = float(valor)
                print(f"   🟢 float(): {resultado_float}")
            else:
                resultado_int = int(valor)
                print(f"   🔵 int(): {resultado_int}")
        elif isinstance(valor, (int, float, bool)):
            resultado_int = int(valor)
            resultado_float = float(valor)
            print(f"   🔵 int(): {resultado_int}")
            print(f"   🟢 float(): {resultado_float}")
    except ValueError:
        print("   ❌ No se puede convertir a número")

print("\n" + "=" * 40)
print("📊 COMPARACIÓN DE MÉTODOS DE FORMATEO:")

# Ejemplo con datos complejos
nombre = "Ana García"
edad = 28
salario = 45000.75
es_activa = True

print(f"\n📋 DATOS DE EJEMPLO:")
print(f"   Nombre: {nombre}")
print(f"   Edad: {edad}")
print(f"   Salario: {salario}")
print(f"   Activa: {es_activa}")

print(f"\n📝 MENSAJE COMPLEJO CON TRES MÉTODOS:")

# 🌟 F-string (recomendado)
mensaje_fstring = f"Empleada: {nombre}, {edad} años, salario: ${salario:,.2f}, estado: {'Activa' if es_activa else 'Inactiva'}"
print(f"\n🌟 F-string (recomendado):")
print(f"   Resultado: {mensaje_fstring}")
print(f"   Legibilidad: ⭐⭐⭐⭐⭐")
print(f"   Rendimiento: ⭐⭐⭐⭐⭐")

# 🔧 Concatenación (fallback)
estado_texto = "Activa" if es_activa else "Inactiva"
mensaje_concat = ("Empleada: " + nombre + ", " + str(edad) + " años, salario: $" + 
                 f"{salario:,.2f}" + ", estado: " + estado_texto)
print(f"\n🔧 Concatenación (fallback):")
print(f"   Resultado: {mensaje_concat}")
print(f"   Legibilidad: ⭐⭐")
print(f"   Rendimiento: ⭐⭐⭐")

# 📚 Format (legacy)
mensaje_format = "Empleada: {}, {} años, salario: ${:,.2f}, estado: {}".format(
    nombre, edad, salario, "Activa" if es_activa else "Inactiva"
)
print(f"\n📚 Format (legacy):")
print(f"   Resultado: {mensaje_format}")
print(f"   Legibilidad: ⭐⭐⭐")
print(f"   Rendimiento: ⭐⭐⭐⭐")

print(f"\n🎯 RECOMENDACIÓN:")
print(f"   Usa f-strings siempre que sea posible (Python 3.6+)")
print(f"   Usa concatenación para casos simples o compatibilidad")
print(f"   Usa format() solo para mantener código legacy")

Consejos para conversiones seguras

1. Siempre verifica antes de convertir

def convertir_a_numero(texto):
    if texto.isdigit():
        return int(texto)
    else:
        print(f"'{texto}' no es un número válido")
        return None

# Uso seguro
resultado = convertir_a_numero("123")  # 123
resultado = convertir_a_numero("abc")  # None

2. Usa try/except para conversiones riesgosas

def convertir_seguro(valor, tipo_destino):
    try:
        if tipo_destino == int:
            return int(valor)
        elif tipo_destino == float:
            return float(valor)
        elif tipo_destino == str:
            return str(valor)
        elif tipo_destino == bool:
            return bool(valor)
    except ValueError:
        print(f"No se puede convertir '{valor}' a {tipo_destino.__name__}")
        return None

# Uso
numero = convertir_seguro("123", int)    # 123
numero = convertir_seguro("abc", int)    # None

3. Recuerda las reglas de conversión a booleano

# Valores que se convierten a False
print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False
print(bool([]))       # False (lista vacía)
print(bool(None))     # False

# Todo lo demás se convierte a True
print(bool(1))        # True
print(bool(-1))       # True
print(bool("Hola"))   # True
print(bool(" "))      # True (espacio no es vacío)

Resumen

La conversión de tipos es como tener máquinas transformadoras en tu almacén, y combinar texto con variables es una habilidad esencial en Python:

🔄 Conversiones de Tipos:

✅ str() convierte cualquier cosa a texto (caja amarilla)
✅ int() convierte a números enteros (caja azul)
✅ float() convierte a números decimales (caja verde)
✅ bool() convierte a verdadero/falso (caja roja)
✅ Siempre verifica que la conversión sea posible
✅ Ten cuidado con la pérdida de información (float a int)
✅ Usa try/except para conversiones riesgosas

📝 Formateo de Strings (Orden de Prioridad):

🥇 1. F-strings (Recomendado - Python 3.6+)

nombre = "Ana"
edad = 25
mensaje = f"Hola {nombre}, tienes {edad} años"

Ventajas:

✅ Más legible y moderno
✅ Mejor rendimiento
✅ Formateo automático de números
✅ Expresiones dentro de las llaves

🥈 2. Concatenación (Fallback - Universal)

nombre = "Ana"
edad = 25
mensaje = "Hola " + nombre + ", tienes " + str(edad) + " años"

Ventajas:

✅ Simple y universal
✅ Funciona en todas las versiones
✅ Fácil de entender

Desventajas:

❌ Requiere conversión manual
❌ Menos legible con muchas variables

🥉 3. Format() (Legacy - Código Antiguo)

nombre = "Ana"
edad = 25
mensaje = "Hola {}, tienes {} años".format(nombre, edad)

Cuándo usar:

📚 Mantener código legacy
📚 Compatibilidad con Python < 3.6
📚 Proyectos que ya usan este estilo

🎯 Guía de Decisión Rápida:

# ✅ SIEMPRE PREFIERE ESTO (Python 3.6+):
mensaje = f"Usuario {nombre} tiene {edad} años y gana ${salario:,.2f}"

# 🔧 USA ESTO SI NECESITAS COMPATIBILIDAD:
mensaje = "Usuario " + nombre + " tiene " + str(edad) + " años"

# 📚 USA ESTO SOLO PARA CÓDIGO LEGACY:
mensaje = "Usuario {} tiene {} años".format(nombre, edad)

💡 Consejos Finales:

Usa f-strings por defecto - Son el estándar moderno
Concatenación para casos simples - Cuando solo unes 2-3 elementos
Format() solo para legacy - Mantener código existente
Siempre convierte tipos - Antes de combinar con texto
Practica los tres métodos - Para entender código de otros

En el siguiente capítulo aprenderemos sobre operadores y expresiones, donde usaremos estas conversiones y formateos para hacer cálculos y comparaciones más complejas.

💡 Consejo del transformador: Los f-strings son como tener una máquina de última generación en tu almacén. Son más rápidos, más fáciles de usar y hacen que tu código se vea profesional. ¡Úsalos siempre que puedas!

Keyboard shortcuts

Python para principiantes: Automatización desde cero