🏗️ De la Teoría a la Práctica: Construyendo Programas como se Construye una Ciudad

La Diferencia entre Aprender y Programar Profesionalmente

Analogía clave: Aprender a programar es como aprender a construir una casa ladrillo por ladrillo. Programar profesionalmente es como planificar y construir una urbanización completa con todos sus servicios.

🏠 Etapa 1: Aprendiendo los Fundamentos (Construyendo una Casa)

Cuando comenzamos a programar, aprendemos los elementos básicos uno por uno:

• 🧱 Variables: Son como los ladrillos – los bloques básicos
• 🔧 Operadores: Las herramientas para trabajar con los datos
• 🚪 Condicionales: Las puertas que se abren según condiciones
• 🔄 Bucles: Los patrones repetitivos (como las ventanas de cada piso)
• 📦 Funciones: Habitaciones con propósitos específicos

Ejemplo simple de principiante:

# Programa básico - como construir una habitación
nombre = "Juan"
edad = 25
if edad >= 18:
    print(f"{nombre} es mayor de edad")
else:
    print(f"{nombre} es menor de edad")

Este código funciona, pero es como tener una sola habitación suelta. No está organizado para proyectos grandes.

🏙️ Etapa 2: Programación Profesional (Construyendo una Urbanización)

Cuando programamos profesionalmente, planificamos primero la estructura completa antes de escribir código:

1️⃣ Primero: La Infraestructura (Las Clases)

Como en una urbanización planificamos primero los servicios básicos:

• 💧 Sistema de agua (Clase de Conexión a Base de Datos)
• ⚡ Sistema eléctrico (Clase de Autenticación)
• 🚰 Sistema de desagüe (Clase de Manejo de Errores)
• 🛣️ Calles y avenidas (Clase de Rutas/Navegación)

2️⃣ Segundo: Las Zonas (Módulos del Sistema)

Dividimos el programa en áreas funcionales:

• 🏠 Zona Residencial: Módulo de Usuarios
• 🏬 Zona Comercial: Módulo de Productos/Ventas
• ⚽ Zona Deportiva: Módulo de Reportes/Análisis
• 🏥 Zona de Salud: Módulo de Respaldo/Recuperación

3️⃣ Tercero: Los Edificios (Clases Específicas)

Cada edificio es una clase con su estructura interna:

• Atributos: Las características del edificio (color, tamaño, número de pisos)
• Métodos: Los servicios que ofrece (abrir, cerrar, mantenimiento)

4️⃣ Cuarto: Las Habitaciones (Funciones y Métodos)

Dentro de cada edificio hay habitaciones con funciones específicas:

• Cada función hace una tarea específica
• Usan variables locales (muebles temporales)
• Aplican lógica con bucles y condicionales

🔄 Cómo se Interconecta Todo en un Programa Real

Imagina un sistema de gestión de biblioteca. Así se conecta todo:

📋 Explicación del Flujo:

1. INICIO DEL PROGRAMA (La Urbanización)El programa inicia cargando la infraestructura básica
2. CLASES PRINCIPALES (Los Edificios)
   • Clase Usuario – Gestiona personas
   • Clase Libro – Gestiona libros
   • Clase Prestamo – Gestiona operaciones
   • Clase Biblioteca – Coordina todo
3. ATRIBUTOS (Las Características)Cada clase tiene sus variables internas:

   class Usuario:
       # Atributos (datos del usuario)
       nombre = "María"
       id = 12345
       libros_prestados = []

4. MÉTODOS (Las Acciones)Cada clase tiene funciones que realizan tareas:

   class Usuario:
       def prestar_libro(self, libro):
           # Usa estructuras de control
           if libro.disponible:
               # Usa variables
               self.libros_prestados.append(libro)
               libro.disponible = False
               return True
           return False

5. BUCLES Y CONDICIONALES (La Lógica Interna)Dentro de los métodos usamos toda la lógica:

   def buscar_libros(self, termino):
       resultados = []
       # BUCLE: Recorre todos los libros
       for libro in self.catalogo:
           # CONDICIONAL: Verifica si coincide
           if termino in libro.titulo:
               resultados.append(libro)
       return resultados

6. INTERCONEXIÓN (Las Calles entre Edificios)Las clases se comunican entre sí:

   class Biblioteca:
       def __init__(self):
           self.usuarios = []  # Lista de objetos Usuario
           self.libros = []    # Lista de objetos Libro
       
       def realizar_prestamo(self, usuario_id, libro_id):
           # Busca el usuario (usa método de otra clase)
           usuario = self.buscar_usuario(usuario_id)
           
           # Busca el libro (usa método de otra clase)
           libro = self.buscar_libro(libro_id)
           
           # Ejecuta el préstamo (usa método de Usuario)
           if usuario.prestar_libro(libro):
               print("Préstamo exitoso")
           else:
               print("No disponible")

📊 Visualización Completa: De los Fundamentos al Sistema

# Variables
nombre = "Juan"

# Operadores
total = a + b

# Condicionales
if edad > 18:
    print("Mayor de edad")

# Bucles
for i in range(10):
    print(i)

def calcular_multa(dias_retraso):
    multa_por_dia = 2.00
    if dias_retraso > 30:
        multa_por_dia = 3.00
    
    total = 0
    for dia in range(dias_retraso):
        total += multa_por_dia
    
    return total

class Prestamo:
    def __init__(self, usuario, libro):
        self.usuario = usuario        # Atributos
        self.libro = libro
        self.fecha_prestamo = hoy()
        self.fecha_devolucion = None
    
    def devolver(self):
        # Método
        self.fecha_devolucion = hoy()
        dias = self.calcular_dias()
        if dias > 15:
            return self.calcular_multa(dias - 15)
        return 0
    
    def calcular_dias(self):
        # Otro método
        # Usa variables y operadores
        return (self.fecha_devolucion - self.fecha_prestamo).days
    
    def calcular_multa(self, dias):
        # Función que vimos antes
        multa_por_dia = 2.00
        if dias > 30:
            multa_por_dia = 3.00
        
        total = 0
        for dia in range(dias):
            total += multa_por_dia
        
        return total

class SistemaBiblioteca:
    def __init__(self):
        self.usuarios = []   # Lista de objetos Usuario
        self.libros = []     # Lista de objetos Libro
        self.prestamos = []  # Lista de objetos Prestamo
    
    def procesar_prestamo(self, usuario_id, libro_id):
        # Busca objetos de otras clases
        usuario = self.encontrar_usuario(usuario_id)
        libro = self.encontrar_libro(libro_id)
        
        # Crea nuevo objeto Prestamo
        prestamo = Prestamo(usuario, libro)
        
        # Actualiza estados usando métodos de otras clases
        usuario.agregar_prestamo(prestamo)
        libro.marcar_prestado()
        self.prestamos.append(prestamo)
        
        return prestamo
    
    def procesar_devolucion(self, prestamo_id):
        prestamo = self.encontrar_prestamo(prestamo_id)
        
        # Llama al método de la clase Prestamo
        multa = prestamo.devolver()
        
        # Actualiza otros objetos
        prestamo.libro.marcar_disponible()
        prestamo.usuario.remover_prestamo(prestamo)
        
        return multa

🎯 Resumen: La Gran Diferencia

💡 Ejemplo Comparativo Final

❌ Código de Principiante (Sin Estructura)

# Todo mezclado, sin organización
usuario1_nombre = "Juan"
usuario1_libros = []
usuario2_nombre = "María"
usuario2_libros = []

libro1_titulo = "Python Básico"
libro1_disponible = True

if libro1_disponible:
    usuario1_libros.append(libro1_titulo)
    libro1_disponible = False

# ¿Qué pasa si tenemos 1000 usuarios y 5000 libros? 🤯

✅ Código Profesional (Con Estructura)

# Infraestructura clara y escalable
class Usuario:
    def __init__(self, nombre):
        self.nombre = nombre
        self.libros_prestados = []
    
    def prestar_libro(self, libro):
        if libro.esta_disponible():
            self.libros_prestados.append(libro)
            libro.marcar_prestado()
            return True
        return False


class Libro:
    def __init__(self, titulo):
        self.titulo = titulo
        self.disponible = True
    
    def esta_disponible(self):
        return self.disponible
    
    def marcar_prestado(self):
        self.disponible = False


class Biblioteca:
    def __init__(self):
        self.usuarios = []
        self.libros = []
    
    def agregar_usuario(self, nombre):
        usuario = Usuario(nombre)
        self.usuarios.append(usuario)
        return usuario
    
    def agregar_libro(self, titulo):
        libro = Libro(titulo)
        self.libros.append(libro)
        return libro


# Uso del sistema (simple y claro)
biblioteca = Biblioteca()
juan = biblioteca.agregar_usuario("Juan")
maria = biblioteca.agregar_usuario("María")
libro = biblioteca.agregar_libro("Python Básico")

juan.prestar_libro(libro)

# Escalable: ¿1000 usuarios y 5000 libros? ¡Sin problema! ✅

Conclusión: Los fundamentos (variables, operadores, condicionales, bucles) son los ladrillos. Las funciones son las habitaciones. Las clases son los edificios. Y el sistema completo es la urbanización donde todo funciona de manera coordinada.

Primero aprendes a hacer ladrillos. Luego aprendes a construir la ciudad. 🏗️➡️🏙️

☁️ Cómo abrir este cuaderno en Google Colab

🔹 Opción 1 — Subir el archivo directamente

1. Descarga el archivo:👉 Fundamentos en modo practico
2. Ve a Google Colab.
3. En el menú, selecciona Archivo → Subir cuaderno.
4. Sube el fichero .ipynb que descargaste.

IMPORTANTE: Para que tu progreso quede registrado y puedas avanzar en el curso, recuerda hacer clic en el botón «Completar» al terminar esta lección.

• Solo al marcar la lección como completada se desbloquearán las siguientes lecciones.
• Es necesario marcar todas las lecciones de este módulo como completadas para poder pasar al Módulo 02.

Cuando termines de revisar el contenido, baja hasta el final de la página y haz clic en «Completar» antes de continuar.