Tipos de Datos Básicos
En nuestro almacén de variables, no todas las cajas son iguales. Cada tipo de caja está diseñada para guardar un tipo específico de información. ¡Vamos a conocer todas las cajas disponibles en Python!
🧱 Una perspectiva personal: Tipos elementales vs compuestos
💭 Nota del autor: Esta es mi perspectiva personal para entender mejor los tipos de datos. No es una definición oficial de Python, pero me ha ayudado mucho a organizar conceptos y espero que te sea útil también.
Desde mi experiencia enseñando Python, me gusta pensar en los tipos de datos como si fueran materiales de construcción en nuestro almacén:
🧱 Tipos Elementales (Los ladrillos básicos)
Son los componentes fundamentales que no se pueden descomponer más. Son como los ladrillos individuales con los que construimos todo lo demás:
- 🔵 int (números enteros):
25,-10,1000 - 🟢 float (números decimales):
3.14,19.99,-2.5 - 🟡 str (texto):
"Ana","Hola mundo","123" - 🔴 bool (verdadero/falso):
True,False - ⚪ None (ausencia de valor):
None
🏗️ Tipos Compuestos (Las estructuras construidas)
Son combinaciones organizadas de tipos elementales. Es como usar nuestros ladrillos básicos para construir estructuras más complejas:
- 📦 Listas:
[25, 30, 35](varios int juntos) - 📋 Tuplas:
("Ana", 25, True)(str, int, bool combinados) - 📚 Diccionarios:
{"nombre": "Ana", "edad": 25}(str como claves, varios tipos como valores) - 🎯 Conjuntos:
{1, 2, 3, 4}(int únicos agrupados)
🔧 La magia de la composición
Lo interesante es que puedes “crear” tipos compuestos usando combinaciones de tipos elementales:
# Tipos elementales (ladrillos básicos)
nombre = "Ana García" # 🟡 str
edad = 28 # 🔵 int
altura = 1.65 # 🟢 float
es_estudiante = True # 🔴 bool
# Tipos compuestos (estructuras construidas con los ladrillos)
persona_lista = [nombre, edad, altura, es_estudiante] # 📦 Lista
persona_tupla = (nombre, edad, altura, es_estudiante) # 📋 Tupla
persona_dict = { # 📚 Diccionario
"nombre": nombre, # str como clave, str como valor
"edad": edad, # str como clave, int como valor
"altura": altura, # str como clave, float como valor
"estudiante": es_estudiante # str como clave, bool como valor
}
print("🧱 Tipos elementales usados:")
print(f" Nombre: {nombre} ({type(nombre).__name__})")
print(f" Edad: {edad} ({type(edad).__name__})")
print(f" Altura: {altura} ({type(altura).__name__})")
print(f" Estudiante: {es_estudiante} ({type(es_estudiante).__name__})")
print("\n🏗️ Tipos compuestos creados:")
print(f" Lista: {persona_lista} ({type(persona_lista).__name__})")
print(f" Tupla: {persona_tupla} ({type(persona_tupla).__name__})")
print(f" Diccionario: {persona_dict} ({type(persona_dict).__name__})")
🎯 ¿Por qué es útil esta perspectiva?
- 📚 Aprendizaje progresivo: Primero dominas los ladrillos básicos, luego aprendes a construir estructuras
- 🔧 Resolución de problemas: Sabes que cualquier estructura compleja está hecha de elementos simples
- 🐛 Depuración: Si algo falla en una estructura compuesta, revisas los elementos individuales
- 💡 Diseño: Planificas mejor qué tipos elementales necesitas para crear tus estructuras
# Ejemplo práctico: Sistema de estudiantes
# Primero definimos los elementos básicos (tipos elementales)
estudiante1_nombre = "Carlos Mendoza" # str
estudiante1_edad = 20 # int
estudiante1_promedio = 8.5 # float
estudiante1_activo = True # bool
estudiante2_nombre = "Ana García" # str
estudiante2_edad = 22 # int
estudiante2_promedio = 9.2 # float
estudiante2_activo = False # bool
# Luego construimos estructuras más complejas (tipos compuestos)
estudiante1 = { # Diccionario usando str, int, float, bool
"nombre": estudiante1_nombre,
"edad": estudiante1_edad,
"promedio": estudiante1_promedio,
"activo": estudiante1_activo
}
estudiante2 = { # Otro diccionario con la misma estructura
"nombre": estudiante2_nombre,
"edad": estudiante2_edad,
"promedio": estudiante2_promedio,
"activo": estudiante2_activo
}
# Y finalmente, estructuras aún más complejas
lista_estudiantes = [estudiante1, estudiante2] # Lista de diccionarios
print("🎓 SISTEMA DE ESTUDIANTES")
print("=" * 40)
for i, estudiante in enumerate(lista_estudiantes, 1):
print(f"Estudiante {i}:")
print(f" 📝 Nombre: {estudiante['nombre']}")
print(f" 🎂 Edad: {estudiante['edad']} años")
print(f" 📊 Promedio: {estudiante['promedio']}")
print(f" ✅ Activo: {estudiante['activo']}")
print()
💡 Reflexión: Observa cómo partimos de 4 tipos elementales simples (str, int, float, bool) y construimos un sistema completo de gestión de estudiantes. ¡Esa es la potencia de la composición!
Los 5 tipos de cajas principales (Tipos Elementales)
🔵 Caja Azul: int (Números Enteros)
Las cajas azules son perfectas para guardar números enteros (sin decimales). Son como cajas resistentes que solo aceptan números completos.
# Creando cajas azules
edad = 25
año_actual = 2024
temperatura = -5
puntos = 0
habitantes = 1000000
# Verificar que son cajas azules
print(type(edad)) # <class 'int'>
¿Cuándo usar cajas azules?
- Edades:
edad = 25 - Años:
año_nacimiento = 1995 - Cantidades exactas:
numero_estudiantes = 30 - Puntuaciones:
puntos_juego = 1500 - Posiciones:
fila = 5,columna = 3
Ejemplos prácticos:
# Información de un estudiante
edad_estudiante = 20
semestre_actual = 6
materias_cursando = 5
creditos_completados = 120
print("=== INFORMACIÓN ACADÉMICA ===")
print("Edad:", edad_estudiante, "años")
print("Semestre:", semestre_actual)
print("Materias este semestre:", materias_cursando)
print("Créditos completados:", creditos_completados)
# Cálculos con cajas azules
creditos_faltantes = 200 - creditos_completados
print("Créditos faltantes:", creditos_faltantes)
Números negativos también son bienvenidos:
temperatura_invierno = -10
deuda = -5000
diferencia_puntos = -25
print("Temperatura:", temperatura_invierno, "°C")
print("Balance:", deuda, "pesos")
🟢 Caja Verde: float (Números Decimales)
Las cajas verdes son especiales para números con decimales. Son como cajas de precisión que pueden guardar fracciones.
# Creando cajas verdes
altura = 1.75
precio = 29.99
temperatura = 36.5
porcentaje = 85.7
pi = 3.14159
# Verificar que son cajas verdes
print(type(altura)) # <class 'float'>
¿Cuándo usar cajas verdes?
- Medidas:
altura = 1.75,peso = 68.5 - Precios:
precio = 199.99 - Temperaturas:
temperatura = 36.5 - Porcentajes:
descuento = 15.5 - Constantes matemáticas:
pi = 3.14159
Ejemplos prácticos:
# Información física de una persona
altura_metros = 1.75
peso_kg = 68.5
temperatura_corporal = 36.8
print("=== DATOS FÍSICOS ===")
print("Altura:", altura_metros, "metros")
print("Peso:", peso_kg, "kg")
print("Temperatura:", temperatura_corporal, "°C")
# Cálculos con cajas verdes
imc = peso_kg / (altura_metros ** 2)
print("IMC:", round(imc, 2)) # Redondeamos a 2 decimales
# Información de compras
precio_producto = 199.99
descuento_porcentaje = 15.5
iva_porcentaje = 16.0
descuento_pesos = precio_producto * (descuento_porcentaje / 100)
precio_con_descuento = precio_producto - descuento_pesos
iva_pesos = precio_con_descuento * (iva_porcentaje / 100)
precio_final = precio_con_descuento + iva_pesos
print("\n=== CÁLCULO DE PRECIO ===")
print("Precio original: $", precio_producto)
print("Descuento (", descuento_porcentaje, "%): $", round(descuento_pesos, 2))
print("Precio con descuento: $", round(precio_con_descuento, 2))
print("IVA (", iva_porcentaje, "%): $", round(iva_pesos, 2))
print("Precio final: $", round(precio_final, 2))
🟡 Caja Amarilla: str (Cadenas de Texto)
Las cajas amarillas son perfectas para guardar texto. Son como cajas mágicas que pueden contener cualquier combinación de letras, números y símbolos, ¡pero siempre entre comillas!
# Creando cajas amarillas
nombre = "Ana García"
mensaje = "¡Hola mundo!"
email = "ana@email.com"
telefono = "555-1234" # Nota: entre comillas porque es texto
direccion = "Calle Falsa 123, Col. Centro"
# Verificar que son cajas amarillas
print(type(nombre)) # <class 'str'>
¿Cuándo usar cajas amarillas?
- Nombres:
nombre = "Ana" - Mensajes:
saludo = "¡Hola!" - Direcciones:
email = "ana@email.com" - Identificadores:
codigo = "ABC123" - Cualquier texto:
descripcion = "Producto de alta calidad"
Formas de crear cajas amarillas:
# Con comillas dobles
nombre = "Ana García"
mensaje = "Ella dijo: 'Hola'"
# Con comillas simples
apellido = 'López'
frase = 'El libro "Python para principiantes" es genial'
# Con comillas triples (para texto largo)
descripcion = """Este es un texto muy largo
que puede ocupar varias líneas
y es perfecto para descripciones detalladas."""
biografia = '''Ana García es una estudiante
de ingeniería en sistemas que le gusta
programar en Python.'''
Ejemplos prácticos:
# Información personal
nombre_completo = "Ana García López"
email_personal = "ana.garcia@email.com"
telefono_celular = "555-123-4567"
ciudad_residencia = "Ciudad de México"
ocupacion = "Estudiante de Ingeniería"
print("=== INFORMACIÓN DE CONTACTO ===")
print("Nombre:", nombre_completo)
print("Email:", email_personal)
print("Teléfono:", telefono_celular)
print("Ciudad:", ciudad_residencia)
print("Ocupación:", ocupacion)
# Mensajes personalizados
saludo_matutino = "¡Buenos días!"
saludo_vespertino = "¡Buenas tardes!"
despedida = "¡Hasta luego!"
print("\n=== MENSAJES ===")
print(saludo_matutino, nombre_completo)
print("Espero que tengas un excelente día.")
print(despedida)
# Información de productos
producto_nombre = "Laptop Gaming Pro"
producto_marca = "TechMaster"
producto_modelo = "GM-2024-X1"
producto_descripcion = "Laptop de alta gama para gaming y trabajo profesional"
print("\n=== INFORMACIÓN DEL PRODUCTO ===")
print("Producto:", producto_nombre)
print("Marca:", producto_marca)
print("Modelo:", producto_modelo)
print("Descripción:", producto_descripcion)
🔴 Caja Roja: bool (Booleanos)
Las cajas rojas son las más simples pero muy importantes. Solo pueden contener dos valores: True (verdadero) o False (falso). Son como interruptores que están encendidos o apagados.
# Creando cajas rojas
es_estudiante = True
tiene_trabajo = False
esta_casado = True
es_fin_semana = False
# Verificar que son cajas rojas
print(type(es_estudiante)) # <class 'bool'>
¿Cuándo usar cajas rojas?
- Estados:
esta_encendido = True - Permisos:
puede_votar = True - Condiciones:
es_mayor_edad = False - Configuraciones:
modo_oscuro = True - Resultados de comparaciones:
es_igual = (5 == 5)
Ejemplos prácticos:
# Estado de un usuario
usuario_activo = True
email_verificado = True
perfil_completo = False
notificaciones_activadas = True
modo_privado = False
print("=== ESTADO DEL USUARIO ===")
print("Usuario activo:", usuario_activo)
print("Email verificado:", email_verificado)
print("Perfil completo:", perfil_completo)
print("Notificaciones:", notificaciones_activadas)
print("Modo privado:", modo_privado)
# Configuración de una aplicación
tema_oscuro = True
sonido_activado = False
actualizaciones_automaticas = True
compartir_ubicacion = False
print("\n=== CONFIGURACIÓN DE LA APP ===")
print("Tema oscuro:", tema_oscuro)
print("Sonido:", sonido_activado)
print("Actualizaciones automáticas:", actualizaciones_automaticas)
print("Compartir ubicación:", compartir_ubicacion)
# Resultados de verificaciones
contraseña_valida = True
edad_suficiente = False
terminos_aceptados = True
print("\n=== VERIFICACIONES ===")
print("Contraseña válida:", contraseña_valida)
print("Edad suficiente:", edad_suficiente)
print("Términos aceptados:", terminos_aceptados)
⚪ Caja Vacía: None (Nada)
La caja vacía es especial. Representa “nada” o “vacío”. Es como tener una caja etiquetada pero sin contenido adentro.
# Creando cajas vacías
resultado = None
valor_inicial = None
respuesta_usuario = None
# Verificar que son cajas vacías
print(type(resultado)) # <class 'NoneType'>
¿Cuándo usar cajas vacías?
- Valores iniciales:
resultado = None - Valores opcionales:
segundo_nombre = None - Indicar ausencia:
fecha_fin = None - Valores por defecto:
configuracion = None
Ejemplos prácticos:
# Información opcional de una persona
nombre = "Ana García"
segundo_nombre = None # No tiene segundo nombre
apellido_materno = "López"
apellido_paterno = None # No se especificó
print("=== INFORMACIÓN PERSONAL ===")
print("Nombre:", nombre)
print("Segundo nombre:", segundo_nombre)
print("Apellido materno:", apellido_materno)
print("Apellido paterno:", apellido_paterno)
# Estado inicial de variables
puntuacion_final = None # Aún no se calcula
fecha_graduacion = None # Aún no se define
trabajo_actual = None # Desempleado
print("\n=== INFORMACIÓN PENDIENTE ===")
print("Puntuación final:", puntuacion_final)
print("Fecha de graduación:", fecha_graduacion)
print("Trabajo actual:", trabajo_actual)
Comparando los tipos de cajas
Vamos a crear un ejemplo que use todos los tipos de cajas:
# ================================
# PERFIL COMPLETO DE USUARIO
# ================================
print("=== CREANDO PERFIL DE USUARIO ===")
print()
# 🟡 Cajas amarillas (texto)
nombre_usuario = "Carlos Mendoza"
email = "carlos.mendoza@email.com"
ciudad = "Guadalajara"
profesion = "Ingeniero de Software"
# 🔵 Cajas azules (números enteros)
edad = 28
años_experiencia = 5
proyectos_completados = 23
# 🟢 Cajas verdes (números decimales)
salario_mensual = 35000.50
altura = 1.78
calificacion_promedio = 4.7
# 🔴 Cajas rojas (verdadero/falso)
esta_empleado = True
busca_trabajo = False
disponible_freelance = True
tiene_auto = True
# ⚪ Cajas vacías (información pendiente)
fecha_ultimo_proyecto = None
siguiente_vacacion = None
# ================================
# MOSTRAR INFORMACIÓN ORGANIZADA
# ================================
print("📋 INFORMACIÓN PERSONAL")
print("Nombre:", nombre_usuario)
print("Email:", email)
print("Ciudad:", ciudad)
print("Profesión:", profesion)
print("Edad:", edad, "años")
print("Altura:", altura, "metros")
print()
print("💼 INFORMACIÓN PROFESIONAL")
print("Años de experiencia:", años_experiencia)
print("Proyectos completados:", proyectos_completados)
print("Salario mensual: $", salario_mensual)
print("Calificación promedio:", calificacion_promedio, "/5.0")
print()
print("✅ ESTADO ACTUAL")
print("Está empleado:", esta_empleado)
print("Busca trabajo:", busca_trabajo)
print("Disponible para freelance:", disponible_freelance)
print("Tiene auto:", tiene_auto)
print()
print("⏳ INFORMACIÓN PENDIENTE")
print("Fecha último proyecto:", fecha_ultimo_proyecto)
print("Siguiente vacación:", fecha_ultimo_proyecto)
print()
print("🔍 TIPOS DE CAJAS UTILIZADAS")
print("nombre_usuario:", type(nombre_usuario))
print("edad:", type(edad))
print("salario_mensual:", type(salario_mensual))
print("esta_empleado:", type(esta_empleado))
print("fecha_ultimo_proyecto:", type(fecha_ultimo_proyecto))
Identificando tipos de cajas
Python te permite “espiar” qué tipo de caja es cada variable:
# Crear diferentes tipos de cajas
mi_nombre = "Ana"
mi_edad = 25
mi_altura = 1.65
soy_estudiante = True
mi_mascota = None
# Espiar qué tipo de caja es cada una
print("=== IDENTIFICANDO TIPOS DE CAJAS ===")
print("mi_nombre es una caja tipo:", type(mi_nombre))
print("mi_edad es una caja tipo:", type(mi_edad))
print("mi_altura es una caja tipo:", type(mi_altura))
print("soy_estudiante es una caja tipo:", type(soy_estudiante))
print("mi_mascota es una caja tipo:", type(mi_mascota))
Ejercicio práctico: Inventario de tu almacén
Vamos a crear un programa que use todos los tipos de cajas:
# ================================
# INVENTARIO DE MI ALMACÉN PERSONAL
# ================================
print("📦 ORGANIZANDO MI ALMACÉN DE VARIABLES")
print("=" * 50)
# Crear una caja de cada tipo
print("\n🟡 Creando caja amarilla (texto)...")
mi_comida_favorita = "Pizza"
print(f" Contenido: {mi_comida_favorita}")
print(f" Tipo de caja: {type(mi_comida_favorita)}")
print("\n🔵 Creando caja azul (número entero)...")
mi_edad = 25 # Cambia por tu edad
print(f" Contenido: {mi_edad}")
print(f" Tipo de caja: {type(mi_edad)}")
print("\n🟢 Creando caja verde (número decimal)...")
mi_estatura = 1.70 # Cambia por tu estatura
print(f" Contenido: {mi_estatura}")
print(f" Tipo de caja: {type(mi_estatura)}")
print("\n🔴 Creando caja roja (verdadero/falso)...")
me_gusta_programar = True # Cambia según tu preferencia
print(f" Contenido: {me_gusta_programar}")
print(f" Tipo de caja: {type(me_gusta_programar)}")
print("\n⚪ Creando caja vacía (None)...")
mi_segundo_apellido = None # Si no tienes segundo apellido
print(f" Contenido: {mi_segundo_apellido}")
print(f" Tipo de caja: {type(mi_segundo_apellido)}")
print("\n" + "=" * 50)
print("📋 RESUMEN DE MI ALMACÉN")
print("=" * 50)
print(f"🟡 Cajas amarillas (str): 1 - Contenido: {mi_comida_favorita}")
print(f"🔵 Cajas azules (int): 1 - Contenido: {mi_edad}")
print(f"🟢 Cajas verdes (float): 1 - Contenido: {mi_estatura}")
print(f"🔴 Cajas rojas (bool): 1 - Contenido: {me_gusta_programar}")
print(f"⚪ Cajas vacías (None): 1 - Contenido: {mi_segundo_apellido}")
print(f"\n📊 Total de cajas en mi almacén: 5")
Consejos para elegir el tipo de caja correcto
1. Para números sin decimales → Caja azul (int)
edad = 25 # ✅ Correcto
edad = 25.0 # ❌ Innecesario (aunque funciona)
2. Para números con decimales → Caja verde (float)
precio = 19.99 # ✅ Correcto
precio = 19 # ❌ Podría perder precisión
3. Para cualquier texto → Caja amarilla (str)
nombre = "Ana" # ✅ Correcto
telefono = "555-1234" # ✅ Correcto (aunque sean números)
4. Para sí/no, verdadero/falso → Caja roja (bool)
es_estudiante = True # ✅ Correcto
es_estudiante = "Sí" # ❌ Menos eficiente
5. Para valores ausentes → Caja vacía (None)
segundo_nombre = None # ✅ Correcto
segundo_nombre = "" # ❌ Cadena vacía, no ausencia
Resumen
🧱 Tipos Elementales (Los fundamentos)
En tu almacén de variables tienes 5 tipos principales de cajas elementales:
- 🔵 Cajas azules (int): Números enteros como 25, -10, 1000
- 🟢 Cajas verdes (float): Números decimales como 3.14, 19.99, -2.5
- 🟡 Cajas amarillas (str): Texto como “Ana”, “Hola mundo”, “123”
- 🔴 Cajas rojas (bool): Solo True o False
- ⚪ Cajas vacías (None): Representan ausencia de valor
🏗️ El camino hacia los tipos compuestos
Estos tipos elementales son tus ladrillos básicos. En capítulos posteriores aprenderás a combinarlos para crear tipos compuestos más sofisticados:
# Hoy aprendiste los ladrillos básicos (tipos elementales)
nombre = "Ana" # 🟡 str
edad = 25 # 🔵 int
activa = True # 🔴 bool
# Próximamente aprenderás a construir estructuras (tipos compuestos)
persona = [nombre, edad, activa] # 📦 Lista (próximo capítulo)
datos = {"nombre": nombre, "edad": edad} # 📚 Diccionario (más adelante)
coordenadas = (10.5, 20.3) # 📋 Tupla (también veremos)
💡 Principios clave
- Domina los elementales primero: Son la base de todo lo demás
- Elige el tipo correcto: Cada tipo tiene su propósito específico
- Piensa en composición: Los tipos complejos se construyen con los simples
- Practica la conversión: Saber cambiar entre tipos es fundamental
Elegir el tipo correcto de caja hace que tu código sea más eficiente y fácil de entender. En la siguiente sección aprenderemos cómo cambiar el contenido de una caja a otro tipo (conversión de tipos).
💡 Consejo del almacenista: Estos tipos elementales son como el alfabeto de la programación. Una vez que los domines, podrás “escribir” estructuras de datos tan complejas como necesites. ¡Recuerda: todo lo complejo está hecho de cosas simples!