🧪 Python Nivel 2 – Parte 9-10: Proyecto CRUD Completo en Consola con POO y JSON

 

🎯 Objetivo del proyecto:

Crear una aplicación funcional por consola que permita gestionar una lista de usuarios con las siguientes operaciones:

• 🔹 Crear usuarios

• 🔹 Leer todos los usuarios

• 🔹 Actualizar un usuario existente

• 🔹 Eliminar usuarios

• 🔹 Guardar los datos en un archivo .json

• 🔹 Recuperarlos al iniciar el programa

---

🗂️ Estructura del sistema

🔧 Clases necesarias:

• Usuario

• GestorUsuarios (controlador del CRUD)

---

💻 Código simplificado

🧱 Clase Usuario

class Usuario:
    def __init__(self, nombre, email):
        self.nombre = nombre
        self.email = email

    def to_dict(self):
        return {"nombre": self.nombre, "email": self.email}

---

🧱 Clase GestorUsuarios

import json
import os

class GestorUsuarios:
    def __init__(self, archivo):
        self.archivo = archivo
        self.usuarios = self.cargar()

    def cargar(self):
        if os.path.exists(self.archivo):
            with open(self.archivo, "r", encoding="utf-8") as f:
                datos = json.load(f)
                return [Usuario(**d) for d in datos]
        return []

    def guardar(self):
        with open(self.archivo, "w", encoding="utf-8") as f:
            json.dump([u.to_dict() for u in self.usuarios], f, indent=4)

    def crear_usuario(self, nombre, email):
        self.usuarios.append(Usuario(nombre, email))
        self.guardar()

    def listar(self):
        for i, u in enumerate(self.usuarios, 1):
            print(f"{i}. {u.nombre} - {u.email}")

    def actualizar(self, indice, nombre, email):
        if 0 <= indice < len(self.usuarios):
            self.usuarios[indice].nombre = nombre
            self.usuarios[indice].email = email
            self.guardar()

    def eliminar(self, indice):
        if 0 <= indice < len(self.usuarios):
            del self.usuarios[indice]
            self.guardar()

---

🧑‍💻 Interfaz por consola

gestor = GestorUsuarios("usuarios.json")

while True:
    print("\n1. Crear usuario\n2. Listar usuarios\n3. Actualizar usuario\n4. Eliminar usuario\n5. Salir")
    opcion = input("Selecciona una opción: ")

    if opcion == "1":
        nombre = input("Nombre: ")
        email = input("Email: ")
        gestor.crear_usuario(nombre, email)

    elif opcion == "2":
        gestor.listar()

    elif opcion == "3":
        gestor.listar()
        i = int(input("Número de usuario a actualizar: ")) - 1
        nombre = input("Nuevo nombre: ")
        email = input("Nuevo email: ")
        gestor.actualizar(i, nombre, email)

    elif opcion == "4":
        gestor.listar()
        i = int(input("Número de usuario a eliminar: ")) - 1
        gestor.eliminar(i)

    elif opcion == "5":
        print("👋 Adiós.")
        break

---

🧠 ¿Qué aprendiste hoy?

✔️ Crear una aplicación CRUD completa con Python
✔️ Usar clases y persistencia con JSON
✔️ Desarrollar menús interactivos
✔️ Aplicar POO en un contexto realista

---

📂 Código completo en GitHub:
github.com/josecodetech

🎥 Video paso a paso en YouTube:
https://www.youtube.com/watch?v=f5yfu-TxWlA

🧪 Python Nivel 2 – Parte 7: Poner en práctica UML con un mini proyecto

Ahora que conoces cómo funciona UML, es momento de aplicarlo a un proyecto práctico donde diseñaremos con UML y luego lo programaremos en Python. Esta actividad te ayudará a consolidar los conceptos de clases, herencia, composición y agregación.

---

🎯 Proyecto: Sistema de Biblioteca

Vamos a construir un sistema sencillo para una biblioteca que permita:

• Registrar libros y usuarios

• Asignar libros a usuarios

• Consultar disponibilidad de libros

---

🗂️ Diseño UML: Clases y Relaciones

Clases involucradas:

1. Libro

   • titulo: str

   • autor: str

   • disponible: bool

   • prestar(), devolver()

2. Usuario

   • nombre: str

   • email: str

   • prestamos: list

3. Biblioteca

   • libros: list

   • usuarios: list

   • agregar_libro(), registrar_usuario(), prestar_libro()

---

🧱 Fragmento UML

--------------------------------
|         Libro                |
--------------------------------
| + titulo: str               |
| + autor: str                |
| + disponible: bool          |
--------------------------------
| + prestar()                 |
| + devolver()                |
--------------------------------

--------------------------------
|         Usuario              |
--------------------------------
| + nombre: str               |
| + email: str                |
| + prestamos: list           |
--------------------------------

--------------------------------
|        Biblioteca           |
--------------------------------
| + libros: list              |
| + usuarios: list            |
--------------------------------
| + agregar_libro()          |
| + registrar_usuario()      |
| + prestar_libro()          |
--------------------------------

---

💻 Código en Python (versión simplificada)

class Libro:
    def __init__(self, titulo, autor):
        self.titulo = titulo
        self.autor = autor
        self.disponible = True

    def prestar(self):
        if self.disponible:
            self.disponible = False
            return True
        return False

    def devolver(self):
        self.disponible = True

class Usuario:
    def __init__(self, nombre, email):
        self.nombre = nombre
        self.email = email
        self.prestamos = []

class Biblioteca:
    def __init__(self):
        self.libros = []
        self.usuarios = []

    def agregar_libro(self, libro):
        self.libros.append(libro)

    def registrar_usuario(self, usuario):
        self.usuarios.append(usuario)

    def prestar_libro(self, titulo, email):
        libro = next((l for l in self.libros if l.titulo == titulo and l.disponible), None)
        usuario = next((u for u in self.usuarios if u.email == email), None)

        if libro and usuario:
            if libro.prestar():
                usuario.prestamos.append(libro)
                print(f"{usuario.nombre} ha tomado prestado '{libro.titulo}'.")
        else:
            print("❌ No se pudo completar el préstamo.")

---

🧠 ¿Qué aprendiste hoy?

✔️ A diseñar con UML antes de programar
✔️ A transformar ese diseño en código Python
✔️ A trabajar con clases relacionadas mediante composición y listas
✔️ A crear una app funcional basada en objetos

---

📂 Código completo en GitHub:
github.com/josecodetech

🎥 Video del mini proyecto en YouTube:
http://youtube.com/watch?v=s4kWoqrTGVM

🧪 Python Nivel 2 – Parte 5: Relaciones entre Clases – Composición y Agregación

Después de aprender herencia, es momento de trabajar otro aspecto clave de la POO: cómo se relacionan las clases entre sí. Esto se logra con técnicas como composición y agregación.

---

🎯 ¿Qué aprenderás hoy?

✅ Qué es la composición y cómo implementarla
✅ Qué es la agregación y en qué se diferencia
✅ Cómo crear relaciones entre clases (uno-a-uno, uno-a-muchos)
✅ Ejemplos prácticos con objetos reales

---

🔧 1. Composición

La composición representa una relación fuerte:

“Un objeto contiene otro como parte esencial.”

Si el objeto principal se destruye, los objetos internos también.

class Motor:
    def arrancar(self):
        print("🔧 Motor en marcha...")

class Coche:
    def __init__(self):
        self.motor = Motor()  # Composición

    def arrancar(self):
        self.motor.arrancar()

auto = Coche()
auto.arrancar()

🧠 Aprendiste:

• El objeto Coche crea y contiene a Motor

• No puedes usar Motor si no existe un Coche

---

🔧 2. Agregación

La agregación representa una relación débil:

“Un objeto usa a otro, pero no lo controla.”

Se pasa como parámetro, y puede vivir por separado.

class Profesor:
    def __init__(self, nombre):
        self.nombre = nombre

class Curso:
    def __init__(self, profesor):
        self.profesor = profesor  # Agregación

    def mostrar(self):
        print(f"Curso impartido por {self.profesor.nombre}")

profe = Profesor("Ana")
curso = Curso(profe)
curso.mostrar()

🧠 Aprendiste:

• El Curso utiliza un Profesor ya existente

• Si destruyes el Curso, el Profesor sigue existiendo

---

🧠 Comparación rápida

Relación	Crea internamente	Independencia
Composición	✅ Sí	❌ No
Agregación	❌ No	✅ Sí

---

🚀 ¿Qué aprendiste hoy?

✔️ A crear relaciones reales entre objetos
✔️ A modelar sistemas complejos como colecciones, vehículos, usuarios, etc.
✔️ A aplicar buenas prácticas de diseño OOP en Python

---

📂 Código completo disponible en:
github.com/josecodetech

💬 ¿Te gustaría un proyecto real usando estas relaciones? ¿Un sistema escolar, app o juego?

🧪 Python Nivel 2 – Parte 4: Constructores, Destructores y Métodos Especiales

 

🎯 ¿Qué aprenderás hoy?

✅ Qué es y cómo se usa el constructor __init__
✅ Cómo implementar un destructor con __del__
✅ Métodos especiales como __str__, __len__, __eq__, __repr__
✅ Cómo hacer que tus objetos se comporten como tipos nativos

---

🔧 1. Constructor __init__()

El constructor se ejecuta automáticamente cuando creas un nuevo objeto. Se usa para inicializar atributos.

class Usuario:
    def __init__(self, nombre, email):
        self.nombre = nombre
        self.email = email

usuario1 = Usuario("Laura", "laura@email.com")
print(usuario1.nombre)

---

🔧 2. Destructor __del__()

El destructor se ejecuta cuando el objeto se elimina. Puede usarse para liberar recursos (memoria, archivos abiertos, conexiones).

class Conexion:
    def __init__(self):
        print("🔌 Conexión establecida.")

    def __del__(self):
        print("❌ Conexión cerrada.")

c = Conexion()
del c  # Esto fuerza la destrucción

---

🔧 3. Método __str__() – Representación legible

Define cómo se muestra el objeto cuando se imprime.

class Producto:
    def __init__(self, nombre, precio):
        self.nombre = nombre
        self.precio = precio

    def __str__(self):
        return f"{self.nombre} - ${self.precio}"

p = Producto("Auriculares", 45.99)
print(p)  # Auriculares - $45.99

---

🔧 4. Otros métodos especiales útiles

Método	Descripción
__len__	Devuelve la longitud
__eq__	Define cómo comparar dos objetos (==)
__repr__	Representación técnica (depuración)
__add__	Define cómo sumar dos objetos

---

✅ Ejemplo de comparación con __eq__

class Libro:
    def __init__(self, titulo):
        self.titulo = titulo

    def __eq__(self, otro):
        return self.titulo == otro.titulo

l1 = Libro("Python Básico")
l2 = Libro("Python Básico")
print(l1 == l2)  # True

---

🚀 ¿Qué aprendiste hoy?

✔️ Cómo inicializar y destruir objetos
✔️ Cómo hacer que tus clases se comporten de forma más intuitiva
✔️ Cómo personalizar funciones internas como print(), ==, len()
✔️ Cómo mejorar la depuración con __repr__

---

📂 Código completo en GitHub:
github.com/josecodetech

🎥 Video paso a paso en YouTube:
https://www.youtube.com/watch?v=F2LKpvepD_c

💬 ¿Qué método especial te parece más útil? ¿Has usado __init__ sin saberlo?

🧪 Python Nivel 2 – Parte 3: Herencia en Programación Orientada a Objetos

En esta lección aprenderás a reutilizar código mediante herencia, un pilar clave de la Programación Orientada a Objetos (POO). Te permitirá crear estructuras organizadas y extender clases de forma eficiente.

---

✅ ¿Qué es la herencia?

La herencia permite que una clase hija herede atributos y métodos de una clase padre. Así se puede reutilizar código y especializar comportamientos sin partir de cero.

---

🔧 Ejemplo 1: Clase base y subclases

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hablar(self):
        print(f"{self.nombre} hace un sonido.")

class Perro(Animal):
    def hablar(self):
        print(f"{self.nombre} dice: ¡Guau!")

class Gato(Animal):
    def hablar(self):
        print(f"{self.nombre} dice: Miau.")

perro = Perro("Rex")
gato = Gato("Michi")

perro.hablar()
gato.hablar()

🧠 Aprendiste:

• Cómo una clase hija sobrescribe métodos

• Que las clases hijas heredan atributos y métodos automáticamente

---

🔧 Ejemplo 2: Constructor extendido con super()

class Vehiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo

class Coche(Vehiculo):
    def __init__(self, marca, modelo, puertas):
        super().__init__(marca, modelo)
        self.puertas = puertas

    def mostrar_info(self):
        print(f"{self.marca} {self.modelo}, {self.puertas} puertas")

coche = Coche("Toyota", "Yaris", 5)
coche.mostrar_info()

🧠 Aprendiste:

• A reutilizar el constructor de la clase padre con super()

• A añadir nuevos atributos en la subclase

---

🚀 ¿Qué aprendiste hoy?

✔️ Crear jerarquías de clases
✔️ Reutilizar y extender código
✔️ Especializar comportamientos en subclases
✔️ Aplicar el principio DRY (Don’t Repeat Yourself)

---

📂 Código completo en GitHub:
github.com/josecodetech

🎥 Video paso a paso en YouTube:
https://www.youtube.com/watch?v=LkxQBDnQIT0

💬 ¿Te gustaría ver un ejemplo real usando herencia para usuarios, productos o personajes de un juego? ¡Coméntalo!

🧪 Python Nivel 2 – Parte 1: Introducción a la Programación Orientada a Objetos

 Después de dominar los fundamentos de Python, es hora de dar el siguiente paso:

✨ Organizar tu código como un profesional con clases y objetos.

---

🧠 ¿Qué es la Programación Orientada a Objetos?

Es un paradigma que permite estructurar el código imitando el mundo real:
📦 Clases → plantillas
🧍 Objetos → instancias únicas
🏷️ Atributos → características
⚙️ Métodos → acciones

---

🔧 Conceptos que aprenderás hoy:

• Qué es una clase y cómo se define

• Cómo crear objetos a partir de clases

• Cómo funcionan los atributos y métodos

• Qué es el constructor __init__

• Qué significa self en Python

---

✅ Ejemplo 1: Crear una clase básica

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def saludar(self):
        print(f"Hola, me llamo {self.nombre} y tengo {self.edad} años.")

# Crear y usar un objeto
persona1 = Persona("Lucía", 29)
persona1.saludar()

---

✅ Ejemplo 2: Modificar atributos

persona1.nombre = "Laura"
persona1.saludar()

🧠 El objeto puede cambiar dinámicamente su información.

---

✅ Ejemplo 3: Crear múltiples objetos

persona2 = Persona("Carlos", 35)
persona3 = Persona("Ana", 42)

persona2.saludar()
persona3.saludar()

---

🚀 ¿Por qué usar POO?

✔️ Mantiene el código limpio y escalable
✔️ Agrupa información y funciones en una sola entidad
✔️ Es la base de librerías, frameworks, APIs y juegos
✔️ Reutilizas estructuras sin reescribir todo

---

📌 Próximo paso:

En la Parte 2 aprenderás:

• Cómo usar métodos especiales (__str__, __repr__)

• Cómo encapsular información

• Cómo crear clases con lógica más compleja

---

📂 Código completo disponible en:
github.com/josecodetech

🎥 Video en YouTube:
https://www.youtube.com/watch?v=YWQe0WrjovI

💬 ¿Te gustaría ver cómo aplicar clases para videojuegos, apps o bots? ¡Déjamelo en los comentarios!