🧪 Python Nivel 2 – Parte 11: Pruebas con assert y Manejo Profesional de Errores

 

🎯 ¿Qué aprenderás en esta parte?

✅ Qué es una prueba con assert y cómo usarla
✅ Cómo detectar errores desde el desarrollo
✅ Cómo crear pruebas simples sin librerías externas
✅ Cómo capturar errores personalizados y mantener controlado tu código

---

🧱 ¿Qué es assert?

assert es una instrucción que permite verificar condiciones durante la ejecución.
Si la condición no se cumple, lanza una excepción (AssertionError) y detiene el programa.

---

🔍 Ejemplo básico:

def dividir(a, b):
    assert b != 0, "El divisor no puede ser cero"
    return a / b

print(dividir(10, 2))   # 5.0
print(dividir(10, 0))   # AssertionError

---

✅ Ventajas de usar assert

✔️ Detecta errores temprano
✔️ Mejora la confiabilidad del código
✔️ Facilita pruebas durante el desarrollo
✔️ Se puede desactivar al ejecutar con python -O

---

🔐 Personalizar errores con try-except

Además de assert, Python permite manejar errores sin que el programa se detenga abruptamente:

try:
    resultado = dividir(10, 0)
except AssertionError as e:
    print("Error capturado:", e)

---

🧑‍💻 Ejemplo práctico: validar emails

def registrar_usuario(nombre, email):
    assert "@" in email, "El email no es válido"
    return {"nombre": nombre, "email": email}

usuario = registrar_usuario("Ana", "ana@correo.com")
print(usuario)

---

🧪 Uso combinado con bucles o inputs

while True:
    edad = input("Introduce tu edad: ")
    try:
        edad = int(edad)
        assert edad > 0, "La edad debe ser positiva"
        break
    except (ValueError, AssertionError) as e:
        print(f"❌ Error: {e}")

---

🧠 ¿Qué aprendiste hoy?

✔️ Cómo usar assert para validar condiciones
✔️ Cómo capturar errores sin romper el programa
✔️ Cómo detectar errores durante el desarrollo
✔️ Cómo crear validaciones más limpias y robustas

---

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

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

🧪 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 8: Guardar y Cargar Objetos con JSON (Persistencia)

 

🎯 ¿Qué aprenderás?

✅ Cómo guardar estructuras de datos en archivos .json
✅ Cómo convertir objetos a diccionarios (__dict__)
✅ Cómo volver a crear objetos desde archivos
✅ Integrar lectura/escritura en tu sistema

---

📁 ¿Por qué usar JSON?

Los objetos en memoria desaparecen al cerrar Python.
Con .json puedes almacenar datos estructurados como diccionarios o listas y volver a cargarlos después.

---

✅ Ejemplo práctico con clases: guardar usuarios

Supongamos que tienes esta clase:

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

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

💾 Guardar lista de usuarios en un archivo

import json

usuarios = [Usuario("Ana", "ana@mail.com"), Usuario("Luis", "luis@mail.com")]

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

---

📂 Cargar usuarios desde el archivo .json

with open("usuarios.json", "r", encoding="utf-8") as f:
    datos = json.load(f)

usuarios_cargados = [Usuario(**d) for d in datos]

for u in usuarios_cargados:
    print(f"{u.nombre} - {u.email}")

🧠 Aprendiste:

• A serializar objetos (convertir a JSON)

• A deserializar (crear objetos desde JSON)

---

🧠 Buenas prácticas

✅ Usar to_dict() para conversión
✅ Separar lógica de guardado en funciones
✅ Validar archivos vacíos o inexistentes
✅ Guardar listas completas (no objetos uno a uno)

---

🚀 ¿Qué aprendiste hoy?

✔️ A persistir tus objetos entre ejecuciones
✔️ A leer y guardar datos estructurados
✔️ A construir sistemas más completos y reutilizables
✔️ A combinar clases + archivos + lógica real

---

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

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

🧪 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 6: UML y Diseño de Clases

 

🎯 ¿Qué aprenderás en esta parte?

✅ Qué es UML y para qué se usa
✅ Cómo representar clases con UML
✅ Cómo planificar relaciones (herencia, composición, agregación)
✅ Cómo traducir un diseño UML en clases Python
✅ Ejemplo completo: diagrama + código

---

📌 ¿Qué es UML?

UML (Unified Modeling Language) es un lenguaje visual para representar sistemas orientados a objetos.
Se utiliza para planificar clases, atributos, métodos y relaciones entre objetos antes de programar.

---

🧱 Estructura de una clase en UML

Un diagrama de clase básico UML incluye:

--------------------------------------
|         NombreClase                |
--------------------------------------
| - atributo1: Tipo                  |
| - atributo2: Tipo                  |
--------------------------------------
| + metodo1(): TipoRetorno          |
| + metodo2(parámetro: Tipo): Retorno |
--------------------------------------

• + = público

• - = privado

• # = protegido

---

🧩 Ejemplo simple en UML

-------------------------
|       Persona         |
-------------------------
| - nombre: str         |
| - edad: int           |
-------------------------
| + saludar(): str      |
-------------------------

Traducción en código Python:

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

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

---

🔗 Relaciones UML

Relación	UML	Ejemplo
Herencia	Flecha abierta	Empleado → Persona
Composición	Rombo negro	Coche ▪── Motor
Agregación	Rombo blanco	Curso ◇── Profesor

---

🧠 ¿Por qué usar UML?

✅ Facilita la planificación antes de codificar
✅ Mejora la comunicación entre programadores
✅ Ayuda a evitar errores de diseño
✅ Documenta mejor tus sistemas

---

✅ ¿Qué aprendiste hoy?

✔️ Leer y escribir diagramas UML
✔️ Representar atributos y métodos
✔️ Comprender relaciones entre clases
✔️ Traducir UML a Python

---

📂 Código de ejemplo completo:
github.com/josecodetech

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

🧪 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 2: Métodos especiales, encapsulamiento y representación

 🎯 ¿Qué aprenderás hoy?

✅ Usar métodos especiales como __str__ y __repr__
✅ Aplicar encapsulamiento con atributos privados
✅ Definir getters y setters
✅ Hacer que tus objetos sean más intuitivos y seguros

---

🔧 1. Método especial __str__

Sirve para representar el objeto cuando lo imprimes.

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

    def __str__(self):
        return f"{self.nombre} ({self.edad} años)"

persona = Persona("Carlos", 30)
print(persona)  # Carlos (30 años)

---

🔧 2. Encapsulamiento: atributos privados

Se indica con doble guión bajo __ al comienzo del atributo.
Esto protege datos que no deberían modificarse directamente.

class CuentaBancaria:
    def __init__(self, titular, saldo):
        self.__titular = titular
        self.__saldo = saldo

    def mostrar_info(self):
        print(f"Titular: {self.__titular}, Saldo: {self.__saldo}")

⚠️ Si intentas acceder directamente a cuenta.__saldo, obtendrás error.

---

🔧 3. Getters y Setters

Métodos que permiten acceder o modificar atributos privados de forma controlada.

class CuentaBancaria:
    def __init__(self, titular, saldo):
        self.__titular = titular
        self.__saldo = saldo

    def get_saldo(self):
        return self.__saldo

    def depositar(self, monto):
        if monto > 0:
            self.__saldo += monto

cuenta = CuentaBancaria("Ana", 1000)
print(cuenta.get_saldo())     # 1000
cuenta.depositar(500)
print(cuenta.get_saldo())     # 1500

---

💡 BONUS: Método __repr__

Se usa más para depuración o representar el objeto en consola/interactivo.

def __repr__(self):
    return f"Persona(nombre={self.nombre}, edad={self.edad})"

---

🧠 ¿Qué ganaste hoy?

✔️ Más control sobre la visibilidad de tus atributos
✔️ Seguridad al modificar datos sensibles
✔️ Representaciones legibles de tus objetos
✔️ Mejores prácticas POO

---

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

🎥 Video paso a paso en YouTube:
https://youtu.be/8lwoAQCer3Q

💬 ¿Ya usaste getters y setters? ¿Conocías __str__? ¡Cuéntamelo!

🧪 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!

🧪 Python Nivel 1 – Parte 10: Ejercicio Integrador – Gestor de Tareas

 🎯 Objetivo:

Crear un programa realista que permita al usuario:

• Añadir tareas

• Marcar tareas como completadas

• Ver tareas pendientes y completadas

• Guardar y recuperar tareas desde un archivo .json

---

📝 Enunciado del proyecto: Gestor de tareas

Escribe un programa que permita al usuario gestionar sus tareas del día. Las tareas se deben guardar en un archivo llamado tareas.json para que no se pierdan al cerrar el programa.

---

✅ Características:

1. Menú principal con opciones:

   • Añadir nueva tarea

   • Ver tareas pendientes

   • Marcar tarea como completada

   • Ver tareas completadas

   • Salir

2. Uso de funciones para cada acción

3. Datos estructurados con listas y diccionarios

4. Lectura y escritura en archivo .json para guardar todo

---

💻 Código completo del proyecto

import json
import os

archivo = "tareas.json"

# Cargar tareas si existe el archivo
def cargar_tareas():
    if os.path.exists(archivo):
        with open(archivo, "r", encoding="utf-8") as f:
            return json.load(f)
    else:
        return {"pendientes": [], "completadas": []}

# Guardar tareas en archivo
def guardar_tareas(tareas):
    with open(archivo, "w", encoding="utf-8") as f:
        json.dump(tareas, f, indent=4)

# Mostrar tareas
def mostrar_tareas(lista, titulo):
    print(f"\n📋 {titulo}:")
    if lista:
        for i, tarea in enumerate(lista, start=1):
            print(f"{i}. {tarea}")
    else:
        print("No hay tareas.")

# Menú principal
def menu():
    tareas = cargar_tareas()

    while True:
        print("\n--- MENÚ ---")
        print("1. Añadir tarea")
        print("2. Ver pendientes")
        print("3. Marcar como completada")
        print("4. Ver completadas")
        print("5. Salir")

        opcion = input("Elige una opción: ")

        if opcion == "1":
            nueva = input("Escribe la nueva tarea: ")
            tareas["pendientes"].append(nueva)
            guardar_tareas(tareas)

        elif opcion == "2":
            mostrar_tareas(tareas["pendientes"], "Tareas pendientes")

        elif opcion == "3":
            mostrar_tareas(tareas["pendientes"], "Tareas pendientes")
            if tareas["pendientes"]:
                try:
                    num = int(input("Número de tarea completada: ")) - 1
                    completada = tareas["pendientes"].pop(num)
                    tareas["completadas"].append(completada)
                    guardar_tareas(tareas)
                except (ValueError, IndexError):
                    print("❌ Entrada inválida.")

        elif opcion == "4":
            mostrar_tareas(tareas["completadas"], "Tareas completadas")

        elif opcion == "5":
            print("✅ Programa cerrado. ¡Hasta pronto!")
            break
        else:
            print("❌ Opción no válida.")

# Ejecutar menú
menu()

---

🧠 ¿Qué se repasa aquí?

✔️ Estructuras condicionales y bucles
✔️ Listas, diccionarios y funciones
✔️ Lectura/escritura de archivos .json
✔️ Validación de entrada del usuario
✔️ Organización y reutilización de código

---

🚀 Próximo paso:

Con este proyecto cierras el Nivel 1 de Python y estás listo para pasar a conceptos intermedios como:

• clases y objetos

• librerías externas

• proyectos web o visuales

---

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

Video tutorial : https://youtu.be/CSeYb1WS7QE