Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Capítulo 4: Variables y Tipos de Datos

¡Felicidades! Ya sabes escribir código Python básico. Ahora vamos a aprender sobre variables, que son una de las herramientas más importantes en programación.

La analogía del almacén con cajas 📦

💭 Nota del autor: Cuando enseño programación, me gusta usar analogías que conecten conceptos abstractos con cosas cotidianas. La analogía del “almacén con cajas” es mi favorita para explicar variables y tipos de datos.

Imagínate que eres el encargado de un almacén gigante. Tienes miles de cajas de diferentes tamaños y colores. Cada caja puede guardar un tipo específico de cosa:

  • Caja azul pequeña → Solo números enteros (como 5, 10, -3)
  • Caja verde mediana → Solo números decimales (como 3.14, -2.5)
  • Caja amarilla grande → Solo texto (como “Hola”, “Python es genial”)
  • Caja roja pequeña → Solo valores de verdadero/falso

En Python, las variables son exactamente como estas cajas. Cada variable:

  • Tiene un nombre (como una etiqueta en la caja)
  • Puede guardar un valor (el contenido de la caja)
  • Tiene un tipo específico (el tipo de caja que es)
# Creando nuestras "cajas" (variables)
edad = 25                    # Caja azul con el número 25
precio = 19.99              # Caja verde con el número 19.99
nombre = "Juan"             # Caja amarilla con el texto "Juan"
es_estudiante = True        # Caja roja con el valor True

¿Qué son las variables?

Una variable es como una caja etiquetada donde puedes guardar información para usarla después. Es uno de los conceptos más fundamentales en programación.

Ejemplo práctico:

# Sin variables (difícil de entender)
print("Hola, mi nombre es Juan")
print("Juan tiene 25 años")
print("Juan vive en México")

# Con variables (mucho más claro)
nombre = "Juan"
edad = 25
pais = "México"

# 🌟 Usando f-strings (recomendado)
print(f"Hola, mi nombre es {nombre}")
print(f"{nombre} tiene {edad} años")
print(f"{nombre} vive en {pais}")

¿Ves la diferencia? Con variables, si quieres cambiar el nombre de “Juan” a “María”, solo cambias una línea en lugar de tres. ¡Esto hace que tu código sea mucho más fácil de mantener!

Creando tu primera variable

En Python, crear una variable es súper fácil:

# Sintaxis: nombre_variable = valor
mi_nombre = "Tu nombre aquí"

Es como tomar una caja, ponerle una etiqueta que dice “mi_nombre”, y meter dentro el texto “Tu nombre aquí”.

Ejemplos de diferentes tipos de cajas:

# Caja para números enteros (int)
edad = 20
puntos = 1500
temperatura = -5

# Caja para números decimales (float)
altura = 1.75
precio = 29.99
pi = 3.14159

# Caja para texto (str)
nombre = "Ana"
mensaje = "¡Hola mundo!"
email = "ana@email.com"

# Caja para verdadero/falso (bool)
es_mayor_edad = True
tiene_mascota = False
esta_lloviendo = True

🧱 Tipos de datos elementales y compuestos

💭 Nota del autor: Me gusta clasificar los tipos de datos en Python en dos grandes categorías: elementales y compuestos. Esta es mi perspectiva personal que me ha ayudado a enseñar estos conceptos de manera más clara.

Tipos Elementales (Los ladrillos básicos)

Los tipos elementales son los componentes fundamentales que no se pueden descomponer más. Son como los ladrillos individuales con los que construiremos todo lo demás:

1. int (Enteros) - La caja azul 🔵

Guarda números enteros (sin decimales):

edad = 25
año_nacimiento = 1998
temperatura = -10
puntos_juego = 0

print(f"La edad es {edad} y su tipo es: {type(edad)}")  # <class 'int'>

Ejemplos de uso:

  • Edad de una persona
  • Cantidad de productos
  • Año
  • Puntuación en un juego

2. float (Decimales) - La caja verde 🟢

Guarda números con decimales:

altura = 1.75
precio = 19.99
temperatura = 36.5
pi = 3.14159

print(f"La altura es {altura} y su tipo es: {type(altura)}")  # <class 'float'>

Ejemplos de uso:

  • Precios
  • Medidas (altura, peso, distancia)
  • Porcentajes
  • Constantes matemáticas

3. str (Cadenas de texto) - La caja amarilla 🟡

Guarda texto (siempre entre comillas):

nombre = "María"
apellido = 'González'  # Comillas simples también funcionan
mensaje = "¡Hola, cómo estás!"
direccion = "Calle Falsa 123"

print(f"El nombre es {nombre} y su tipo es: {type(nombre)}")  # <class 'str'>

Ejemplos de uso:

  • Nombres y apellidos
  • Direcciones
  • Mensajes
  • Cualquier texto

4. bool (Booleanos) - La caja roja 🔴

Guarda solo dos valores: True o False:

es_estudiante = True
tiene_trabajo = False
esta_casado = True
es_fin_semana = False

print(f"¿Es estudiante? {es_estudiante} - Tipo: {type(es_estudiante)}")  # <class 'bool'>

Ejemplos de uso:

  • Estados (encendido/apagado)
  • Condiciones (sí/no)
  • Permisos (permitido/no permitido)
  • Cualquier cosa que sea verdadero o falso

5. NoneType - La caja vacía ⚪

Representa “nada” o “vacío”:

resultado = None
valor_inicial = None

print(f"El resultado es {resultado} y su tipo es: {type(resultado)}")  # <class 'NoneType'>

Tipos Compuestos (Las estructuras construidas)

💭 Nota del autor: En capítulos posteriores veremos en detalle estos tipos compuestos, pero quiero mencionarlos ahora para que tengas una visión completa.

Los tipos compuestos son combinaciones organizadas de tipos elementales. Es como usar nuestros ladrillos básicos para construir estructuras más complejas:

# 📦 Lista - colección ordenada y modificable
nombres = ["Ana", "Carlos", "Luis"]  # Una caja con compartimentos

# 📋 Tupla - colección ordenada e inmutable
coordenadas = (10.5, 20.8)  # Una caja sellada

# 📚 Diccionario - colección de pares clave-valor
persona = {"nombre": "Ana", "edad": 25}  # Una caja con etiquetas internas

# 🎯 Conjunto - colección desordenada de elementos únicos
colores = {"rojo", "verde", "azul"}  # Una caja que elimina duplicados

Intercambiando contenido entre cajas

Una de las cosas geniales de las variables es que puedes cambiar su contenido:

# Empezamos con una caja
mi_caja = "Hola"
print(f"Contenido inicial: {mi_caja}")  # Hola

# Cambiamos el contenido de la misma caja
mi_caja = "Adiós"
print(f"Nuevo contenido: {mi_caja}")  # Adiós

# Incluso podemos cambiar el tipo de contenido
mi_caja = 42
print(f"Contenido cambiado a número: {mi_caja}")  # 42

mi_caja = True
print(f"Contenido cambiado a booleano: {mi_caja}")  # True

Esto es como tomar la misma caja, vaciarla, y meter algo completamente diferente. En Python esto es posible porque es un lenguaje de tipado dinámico, lo que significa que una variable puede cambiar de tipo durante la ejecución del programa.

💡 Comprueba tu comprensión: ¿Qué pasaría si intentas sumar mi_caja + 10 después de cada cambio de valor? ¿Funcionaría en todos los casos?

Ejemplo práctico: Perfil de usuario

Vamos a crear un programa que use diferentes tipos de cajas para guardar información de una persona:

# ================================
# INFORMACIÓN PERSONAL
# ================================
# Cajas de texto (str)
nombre = "Ana García"
apellido = "López"
email = "ana.garcia@email.com"
ciudad = "Ciudad de México"

# Cajas de números enteros (int)
edad = 28
año_nacimiento = 1995
numero_hijos = 2

# Cajas de números decimales (float)
altura = 1.65
peso = 58.5
salario = 25000.50

# Cajas de verdadero/falso (bool)
es_estudiante = False
tiene_trabajo = True
esta_casado = True
tiene_mascota = True

# ================================
# MOSTRAR INFORMACIÓN
# ================================
print("=== PERFIL DE USUARIO ===")
# 🌟 Usando f-strings para mostrar información
print(f"Nombre completo: {nombre} {apellido}")
print(f"Email: {email}")
print(f"Ciudad: {ciudad}")
print()

print("=== DATOS PERSONALES ===")
print(f"Edad: {edad} años")
print(f"Año de nacimiento: {año_nacimiento}")
print(f"Altura: {altura} metros")
print(f"Peso: {peso} kg")
print()

print("=== ESTADO ACTUAL ===")
# Usando expresiones condicionales dentro de f-strings
print(f"Estudiante: {'✓ Sí' if es_estudiante else '✗ No'}")
print(f"Trabajo: {'✓ Sí' if tiene_trabajo else '✗ No'}")
if tiene_trabajo:
    print(f"Salario: ${salario:,.2f} pesos")  # Con formato de miles y 2 decimales
print(f"Estado civil: {'✓ Casado/a' if esta_casado else '✗ Soltero/a'}")
print(f"Mascota: {'✓ Sí' if tiene_mascota else '✗ No'}")
print(f"Número de hijos: {numero_hijos}")

# ================================
# CÁLCULOS CON VARIABLES
# ================================
print("\n=== CÁLCULOS ADICIONALES ===")
imc = peso / (altura ** 2)
print(f"Índice de Masa Corporal: {imc:.2f}")
años_trabajando = edad - 22  # Suponiendo que empezó a trabajar a los 22
print(f"Años aproximados trabajando: {años_trabajando}")
salario_anual = salario * 12
print(f"Salario anual estimado: ${salario_anual:,.2f} pesos")

💡 Comprueba tu comprensión: ¿Cómo modificarías este programa para incluir información sobre estudios universitarios? ¿Qué variables añadirías y de qué tipo serían?

Reglas para nombrar cajas (variables)

Así como no puedes poner cualquier etiqueta en una caja, Python tiene reglas para nombrar variables:

✅ Nombres válidos:

nombre = "Juan"
edad_usuario = 25
mi_variable = 100
_variable_privada = "secreto"
variable2 = "segunda"
CONSTANTE = 3.14159

❌ Nombres inválidos:

2nombre = "Juan"        # No puede empezar con número
mi-variable = 100       # No puede tener guiones
mi variable = 100       # No puede tener espacios
if = 25                 # No puede ser palabra reservada

🎯 Buenas prácticas para nombres:

1. Usa nombres descriptivos

# ✅ BUENO - se entiende qué contiene
nombre_usuario = "Ana"
edad_en_años = 25
precio_producto = 19.99

# ❌ MALO - no se entiende qué es
n = "Ana"
x = 25
p = 19.99

2. Usa snake_case (guiones bajos)

# ✅ BUENO - estilo Python
nombre_completo = "Ana García"
fecha_nacimiento = "1995-05-15"
es_mayor_edad = True

# ❌ MALO - no es el estilo de Python
nombreCompleto = "Ana García"      # camelCase
NombreCompleto = "Ana García"      # PascalCase

3. Sé consistente

# ✅ BUENO - mismo patrón
nombre_usuario = "Ana"
apellido_usuario = "García"
email_usuario = "ana@email.com"

# ❌ MALO - patrones mezclados
nombre_usuario = "Ana"
apellidoUsuario = "García"
EMAIL = "ana@email.com"

💭 Nota del autor: Después de años programando, he aprendido que el tiempo que inviertes en nombrar bien tus variables se recupera con creces cuando tienes que revisar o modificar tu código semanas o meses después. Un buen nombre de variable es como una buena señalización en una carretera: te dice exactamente dónde estás y hacia dónde vas.

Viendo qué hay dentro de las cajas

Python te permite “espiar” dentro de las cajas para ver qué tipo de contenido tienen usando la función type():

# Crear diferentes tipos de cajas
numero = 42
texto = "Hola"
decimal = 3.14
verdadero = True

# Ver qué tipo de caja es cada una
print(f"numero es tipo: {type(numero)}")      # <class 'int'>
print(f"texto es tipo: {type(texto)}")        # <class 'str'>
print(f"decimal es tipo: {type(decimal)}")    # <class 'float'>
print(f"verdadero es tipo: {type(verdadero)}") # <class 'bool'>

Es como tener una máquina de rayos X que te permite ver qué tipo de contenido hay dentro de cada caja sin tener que abrirla.

Ejercicio práctico: Tu información personal

Vamos a crear un programa que use la analogía de las cajas para guardar tu información:

# ================================
# EJERCICIO: MIS CAJAS PERSONALES
# ================================

print("=== CREANDO MIS CAJAS DE INFORMACIÓN ===")
print()

# Caja amarilla para tu nombre
mi_nombre = "Tu nombre aquí"
print(f"📦 Caja amarilla (texto): {mi_nombre}")

# Caja azul para tu edad
mi_edad = 25  # Cambia por tu edad real
print(f"📦 Caja azul (número entero): {mi_edad}")

# Caja verde para tu altura
mi_altura = 1.70  # Cambia por tu altura real
print(f"📦 Caja verde (número decimal): {mi_altura}")

# Caja roja para si eres estudiante
soy_estudiante = True  # Cambia por tu situación real
print(f"📦 Caja roja (verdadero/falso): {soy_estudiante}")

print()
print("=== INFORMACIÓN DE MIS CAJAS ===")
print(f"Nombre: {mi_nombre} - Tipo: {type(mi_nombre)}")
print(f"Edad: {mi_edad} - Tipo: {type(mi_edad)}")
print(f"Altura: {mi_altura} - Tipo: {type(mi_altura)}")
print(f"Estudiante: {soy_estudiante} - Tipo: {type(soy_estudiante)}")

# Añadamos algunos cálculos
print("\n=== CÁLCULOS CON MIS DATOS ===")
edad_en_meses = mi_edad * 12
print(f"Mi edad en meses: {edad_en_meses}")
altura_en_cm = mi_altura * 100
print(f"Mi altura en centímetros: {altura_en_cm}")
años_hasta_jubilacion = 65 - mi_edad
print(f"Años hasta la jubilación: {años_hasta_jubilacion}")

Tu tarea:

  1. Copia este código
  2. Cambia los valores por tu información real
  3. Ejecuta el programa
  4. Añade al menos 3 variables más con diferentes tipos de datos
  5. Crea al menos 2 cálculos adicionales usando tus variables

💡 Desafío adicional: Intenta crear una variable que combine información de otras variables. Por ejemplo, una variable presentacion que contenga un texto que use tu nombre y edad.

Intercambiando cajas

Una cosa interesante es que puedes tomar el contenido de una caja y ponerlo en otra:

# Crear las cajas originales
caja_a = "Hola"
caja_b = "Mundo"

print("Antes del intercambio:")
print(f"Caja A: {caja_a}")
print(f"Caja B: {caja_b}")

# Intercambiar contenido (necesitamos una caja temporal)
caja_temporal = caja_a  # Guardamos el contenido de A
caja_a = caja_b         # Ponemos el contenido de B en A
caja_b = caja_temporal  # Ponemos el contenido temporal en B

print("Después del intercambio:")
print(f"Caja A: {caja_a}")
print(f"Caja B: {caja_b}")

En Python hay una forma más fácil y elegante:

# Intercambio fácil en Python
caja_a, caja_b = caja_b, caja_a

¡Es como si Python fuera un mago que puede intercambiar el contenido de las cajas instantáneamente! Esta es una característica especial de Python que no todos los lenguajes de programación tienen.

💡 Comprueba tu comprensión: ¿Qué pasaría si intentas intercambiar tres variables a la vez? Por ejemplo: a, b, c = c, a, b. ¿Cuáles serían los valores finales?

Resumen del capítulo

En este capítulo aprendiste:

  • ✅ Variables son como cajas que guardan información
  • ✅ Los tipos elementales son los ladrillos básicos (int, float, str, bool, None)
  • ✅ Los tipos compuestos son estructuras construidas con tipos elementales
  • ✅ Puedes cambiar el contenido de las cajas en cualquier momento
  • ✅ Reglas para nombrar las cajas (variables) en Python
  • ✅ Buenas prácticas para nombres descriptivos y consistentes
  • ✅ Cómo ver el tipo de contenido con type()
  • ✅ Cómo usar f-strings para mostrar variables en texto

¿Qué sigue?

En el siguiente capítulo vamos a aprender sobre conversión de tipos. Descubrirás:

  • Cómo cambiar el contenido de una caja azul (int) a una caja verde (float)
  • Cómo convertir números a texto y viceversa
  • Qué pasa cuando intentas mezclar diferentes tipos de cajas
  • Trucos para trabajar con diferentes tipos de datos
  • Más sobre f-strings y formateo de texto

¡Ya tienes tus cajas organizadas, ahora vamos a aprender a transformar su contenido! 📦➡️📦

💡 Consejo del capítulo: Piensa siempre en las variables como cajas etiquetadas y en los tipos de datos como materiales de construcción. Los tipos elementales son tus ladrillos básicos, y con ellos construirás estructuras más complejas (tipos compuestos) en los próximos capítulos. Esta forma de pensar te ayudará a entender conceptos más avanzados como listas (cajas con compartimentos) y diccionarios (cajas con etiquetas internas). ¡La programación es como organizar y construir en un almacén gigante!