Programacion: 2025

miércoles, 16 de julio de 2025

🧪 Python Nivel 2 – Parte 16: Gestión de Dependencias con pip y Archivos requirements.txt

🎯 ¿Qué aprenderás?

✅ Qué es pip y cómo instalar librerías externas
✅ Cómo crear y usar un requirements.txt
✅ Cómo compartir tu entorno de desarrollo
✅ Buenas prácticas para proyectos colaborativos

🧱 ¿Qué es `pip`?

pip es el gestor de paquetes de Python.
Con él puedes instalar librerías externas con un solo comando:


pip install requests

Esto te permite reutilizar librerías que otros desarrolladores han publicado.

🗂 ¿Qué es un archivo `requirements.txt`?

Es un archivo de texto donde defines todas las dependencias necesarias de tu proyecto, línea por línea.


requests==2.31.0
flask==2.3.2

🔧 Cómo generarlo automáticamente:


pip freeze > requirements.txt

Esto guarda todas las librerías y versiones que tienes en tu entorno actual.

🔄 Cómo instalar dependencias desde el archivo:


pip install -r requirements.txt

✅ Así puedes compartir tu proyecto con otros, y podrán instalar todo de forma automática.

🧪 Ejemplo paso a paso:

Crea un entorno virtual:
```
python -m venv venv
```
Actívalo:
- En Windows: venv\Scripts\activate
- En macOS/Linux: source venv/bin/activate
Instala una librería:
```
pip install rich
```
Guarda dependencias:
```
pip freeze > requirements.txt
```
Usa requirements.txt en cualquier máquina:
```
pip install -r requirements.txt
```

📦 Buenas prácticas

✔️ Siempre usa entornos virtuales
✔️ No subas carpetas venv al repositorio
✔️ Usa requirements.txt para compartir dependencias
✔️ Usa pip freeze solo dentro del entorno virtual

🧠 ¿Qué aprendiste hoy?

✔️ Cómo instalar paquetes externos con pip
✔️ Cómo crear y usar un archivo requirements.txt
✔️ Cómo colaborar y compartir tu proyecto fácilmente
✔️ Buenas prácticas para un entorno Python profesional

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

🎥 Video explicativo en YouTube:
https://youtu.be/kKdl9ZoajV0

jueves, 10 de julio de 2025

🧪 Python Nivel 2 – Parte 15: Introducción a Testing con unittest

🎯 ¿Qué aprenderás?

✅ Qué es el testing y por qué es esencial
✅ Cómo crear tests automatizados con unittest
✅ Qué es un test case y cómo definirlo
✅ Cómo comprobar que el código funciona correctamente
✅ Qué hacer cuando un test falla

🧱 ¿Qué es `unittest`?

unittest es el módulo estándar de Python para pruebas automatizadas.
Permite crear clases de test que validan que tus funciones y métodos se comporten correctamente.

📦 Estructura básica de un test:


import unittest

def suma(a, b):
    return a + b

class TestSuma(unittest.TestCase):
    def test_suma_positivos(self):
        self.assertEqual(suma(2, 3), 5)

    def test_suma_negativos(self):
        self.assertEqual(suma(-2, -3), -5)

if __name__ == '__main__':
    unittest.main()

✅ ¿Qué hace cada parte?

import unittest: importa el framework
class TestX(unittest.TestCase): define un grupo de tests
self.assertEqual(...): compara resultado esperado con resultado real
unittest.main(): ejecuta todos los tests definidos

🧪 Otros métodos de validación


self.assertNotEqual(a, b)
self.assertTrue(condición)
self.assertFalse(condición)
self.assertIn(valor, lista)
self.assertRaises(ErrorEsperado, funcion, args)

💡 ¿Cuándo hacer testing?

✔️ Al desarrollar funciones críticas
✔️ Cuando mantienes proyectos grandes
✔️ Al trabajar en equipo
✔️ Para prevenir errores en producción

🧑‍💻 Ejemplo real con clase Usuario


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

    def saludo(self):
        return f"Hola, {self.nombre}"

class TestUsuario(unittest.TestCase):
    def test_saludo(self):
        u = Usuario("Ana")
        self.assertEqual(u.saludo(), "Hola, Ana")

🧠 ¿Qué aprendiste hoy?

✔️ A automatizar pruebas con unittest
✔️ A validar comportamientos de funciones y clases
✔️ A escribir código más confiable y profesional
✔️ A detectar errores antes de que lleguen al usuario

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

🎥 Video paso a paso en YouTube:
https://youtu.be/-2Dj28lOn8E

miércoles, 9 de julio de 2025

🧪 Python Nivel 2 – Parte 14: Uso de Decoradores (Decorators) en Python

🎯 ¿Qué aprenderás?

✅ Qué son los decoradores y para qué sirven
✅ Cómo crear y aplicar decoradores
✅ Cómo usarlos para validar, medir tiempos o modificar comportamiento
✅ Decoradores anidados y con parámetros

🧱 ¿Qué es un decorador?

Un decorador en Python es una función que recibe otra función como argumento y devuelve una nueva función con funcionalidades añadidas, sin modificar su estructura interna.

🔧 Sintaxis básica


def mi_decorador(funcion_original):
    def nueva_funcion():
        print("Antes de ejecutar")
        funcion_original()
        print("Después de ejecutar")
    return nueva_funcion

@mi_decorador
def saludar():
    print("Hola!")

saludar()

🧠 Salida:


Antes de ejecutar  
Hola!  
Después de ejecutar

✅ ¿Para qué sirven los decoradores?

✔️ Validar parámetros
✔️ Medir tiempos de ejecución
✔️ Agregar logs o registros
✔️ Controlar permisos o acceso
✔️ Reutilizar código sin repetir lógica

🕐 Ejemplo: medir tiempo de ejecución


import time

def medir_tiempo(func):
    def wrapper(*args, **kwargs):
        inicio = time.time()
        resultado = func(*args, **kwargs)
        fin = time.time()
        print(f"Tiempo: {fin - inicio:.2f}s")
        return resultado
    return wrapper

@medir_tiempo
def procesar():
    time.sleep(2)
    print("Proceso terminado")

procesar()

🧩 Decorador con argumentos


def repetir(n):
    def decorador(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorador

@repetir(3)
def hola():
    print("Hola!")

hola()

🧠 ¿Qué aprendiste hoy?

✔️ Qué son y cómo funcionan los decoradores
✔️ Cómo aplicarlos en funciones reales
✔️ Cómo pasar parámetros a los decoradores
✔️ A reutilizar lógica de forma limpia y elegante

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

🎥 Video explicativo en YouTube:
https://youtu.be/oloxPaRSGpg

🧪 Python Nivel 2 – Parte 13: Documentar tu Código con Docstrings y Buenas Prácticas

🎯 ¿Qué aprenderás?

✅ Qué es un docstring y cómo escribirlo correctamente
✅ Cómo documentar funciones, clases y módulos
✅ Cómo generar documentación automática
✅ Buenas prácticas para que tu código sea más legible y mantenible

🧱 ¿Qué es un Docstring?

Un docstring es un texto descriptivo que se coloca justo después de la definición de una función, clase o módulo.
Se escribe entre triples comillas (""" """") y sirve para explicar qué hace, qué parámetros recibe y qué devuelve.

🧑‍💻 Ejemplo de función con docstring


def saludar(nombre):
    """
    Devuelve un saludo personalizado.

    Parámetros:
    nombre (str): El nombre de la persona a saludar.

    Retorna:
    str: Un saludo con el nombre.
    """
    return f"Hola, {nombre}!"

📦 Docstring en una clase


class Usuario:
    """
    Representa un usuario con nombre y email.
    """

    def __init__(self, nombre, email):
        """
        Inicializa un nuevo usuario.

        Parámetros:
        nombre (str): Nombre del usuario.
        email (str): Correo electrónico del usuario.
        """
        self.nombre = nombre
        self.email = email

🧰 Buenas prácticas al documentar

✔️ Usa lenguaje claro y conciso
✔️ Explica entradas y salidas
✔️ Usa estilo PEP 257 (recomendado en Python)
✔️ Incluye ejemplos cuando sea útil

🧪 Acceder al docstring en tiempo de ejecución


print(saludar.__doc__)
help(saludar)

📄 Docstring de módulo

Coloca un docstring al principio del archivo .py:


"""
Módulo para gestionar usuarios y sus datos.

Contiene:
- Clase Usuario
- Funciones de validación
"""

🚀 ¿Qué aprendiste hoy?

✔️ A escribir documentación integrada con docstrings
✔️ A aplicar buenas prácticas de código limpio
✔️ A facilitar el mantenimiento de tus programas
✔️ A comunicarte mejor con tu futuro yo (o tu equipo)

📂 Ejemplos documentados en GitHub:
github.com/josecodetech

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

domingo, 6 de julio de 2025

🧪 Python Nivel 2 – Parte 12: Gestión de Errores Personalizados y Excepciones Propias

🎯 ¿Qué aprenderás en esta parte?

✅ Cómo definir tus propias excepciones en Python
✅ Cuándo y por qué usar errores personalizados
✅ Cómo lanzar errores con raise
✅ Cómo capturarlos y diferenciarlos de otros errores
✅ Aplicación en sistemas reales: validaciones y reglas de negocio

🧱 ¿Qué son las excepciones personalizadas?

Son clases propias que heredan de Exception y te permiten controlar errores con más precisión y dar mensajes específicos a cada situación.

🔧 Ejemplo básico:


class EdadInvalidaError(Exception):
    pass

def verificar_edad(edad):
    if edad < 18:
        raise EdadInvalidaError("Debes ser mayor de edad.")

📦 ¿Por qué usar excepciones propias?

✔️ Identificas claramente el tipo de error
✔️ Mejoras la organización del código
✔️ Ayudas a otros desarrolladores a entender tu lógica
✔️ Puedes aplicar reglas de negocio complejas fácilmente

🧑‍💻 Ejemplo real: Sistema de usuarios


class UsuarioExistenteError(Exception):
    pass

usuarios_registrados = ["ana@mail.com", "luis@mail.com"]

def registrar_usuario(email):
    if email in usuarios_registrados:
        raise UsuarioExistenteError("El usuario ya está registrado.")
    usuarios_registrados.append(email)

🧪 Capturando errores personalizados


try:
    registrar_usuario("ana@mail.com")
except UsuarioExistenteError as e:
    print("⚠️ Error:", e)

🔁 Jerarquía de excepciones propias

Puedes crear subtipos para organizar mejor errores:


class ErrorUsuario(Exception): pass
class UsuarioExistenteError(ErrorUsuario): pass
class EmailInvalidoError(ErrorUsuario): pass

🧠 ¿Qué aprendiste hoy?

✔️ A crear tus propias excepciones con clases
✔️ A lanzar errores específicos con raise
✔️ A capturar errores personalizados con try-except
✔️ A mejorar la claridad y control de tus validaciones

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

🎥 Video paso a paso en YouTube:
https://youtu.be/6gpdqmTc8aE

sábado, 5 de julio de 2025

🎓 Aprende Python gratis con certificado – ¡3 cursos disponibles solo para los 1000 primeros!

¿Quieres aprender a programar con Python y obtener certificado totalmente gratis?

He creado cupones exclusivos para acceder sin coste a 3 cursos completos en Udemy, cada uno con certificado de finalización. ¡Pero atención! Solo estarán disponibles para los primeros 1000 inscritos en cada curso.

🔹 Curso 1 – Programación con Python y Copilot
💻 Aprende a programar con la ayuda de la IA de GitHub Copilot en Visual Studio Code.
🎓 Accede gratis al curso

🔹 Curso 2 – Interfaces gráficas con Tkinter
🖥️ Crea tus propias aplicaciones visuales usando Python y Tkinter.
🎓 Accede gratis al curso

🔹 Curso 3 – Web Scraping con Python
🌐 Aprende a extraer datos de páginas web con Python de forma práctica y profesional.
🎓 Accede gratis al curso

📌 Recuerda: son cursos 100% prácticos, pensados para que aprendas paso a paso, con proyectos reales y obtengas un certificado que podrás añadir a tu currículum.

📺 Además, en mi canal de YouTube @josecodetech tienes aún más contenido, ejercicios y recursos complementarios para seguir aprendiendo programación.

✅ ¡Comparte esta publicación y no olvides valorar los cursos adecuadamente si te resultan útiles!
Gracias por formar parte de esta comunidad de aprendizaje 🚀

domingo, 29 de junio de 2025

🧪 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

lunes, 23 de junio de 2025

🧪 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

jueves, 19 de junio de 2025

🧪 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

domingo, 15 de junio de 2025

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

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()

🧱 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?

miércoles, 16 de julio de 2025

🎯 ¿Qué aprenderás?

🧱 ¿Qué es pip?

🗂 ¿Qué es un archivo requirements.txt?

🔧 Cómo generarlo automáticamente:

🔄 Cómo instalar dependencias desde el archivo:

🧪 Ejemplo paso a paso:

📦 Buenas prácticas

🧠 ¿Qué aprendiste hoy?

jueves, 10 de julio de 2025

🎯 ¿Qué aprenderás?

🧱 ¿Qué es unittest?

📦 Estructura básica de un test:

✅ ¿Qué hace cada parte?

🧪 Otros métodos de validación

💡 ¿Cuándo hacer testing?

🧑‍💻 Ejemplo real con clase Usuario

🧠 ¿Qué aprendiste hoy?

miércoles, 9 de julio de 2025

🎯 ¿Qué aprenderás?

🧱 ¿Qué es un decorador?

🔧 Sintaxis básica

✅ ¿Para qué sirven los decoradores?

🕐 Ejemplo: medir tiempo de ejecución

🧩 Decorador con argumentos

🧠 ¿Qué aprendiste hoy?

🎯 ¿Qué aprenderás?

🧱 ¿Qué es un Docstring?

🧑‍💻 Ejemplo de función con docstring

📦 Docstring en una clase

🧰 Buenas prácticas al documentar

🧪 Acceder al docstring en tiempo de ejecución

📄 Docstring de módulo

🚀 ¿Qué aprendiste hoy?

domingo, 6 de julio de 2025

🎯 ¿Qué aprenderás en esta parte?

🧱 ¿Qué son las excepciones personalizadas?

🔧 Ejemplo básico:

📦 ¿Por qué usar excepciones propias?

🧑‍💻 Ejemplo real: Sistema de usuarios

🧪 Capturando errores personalizados

🔁 Jerarquía de excepciones propias

🧠 ¿Qué aprendiste hoy?

sábado, 5 de julio de 2025

domingo, 29 de junio de 2025

🎯 ¿Qué aprenderás en esta parte?

🧱 ¿Qué es assert?

🔍 Ejemplo básico:

✅ Ventajas de usar assert

🔐 Personalizar errores con try-except

🧑‍💻 Ejemplo práctico: validar emails

🧪 Uso combinado con bucles o inputs

🧠 ¿Qué aprendiste hoy?

lunes, 23 de junio de 2025

🎯 Objetivo del proyecto:

🗂️ Estructura del sistema

🔧 Clases necesarias:

💻 Código simplificado

🧱 Clase Usuario

🧱 Clase GestorUsuarios

🧑‍💻 Interfaz por consola

🧠 ¿Qué aprendiste hoy?

jueves, 19 de junio de 2025

🎯 ¿Qué aprenderás?

📁 ¿Por qué usar JSON?

✅ Ejemplo práctico con clases: guardar usuarios

💾 Guardar lista de usuarios en un archivo

📂 Cargar usuarios desde el archivo .json

🧠 Buenas prácticas

🚀 ¿Qué aprendiste hoy?

domingo, 15 de junio de 2025

🎯 Proyecto: Sistema de Biblioteca

🗂️ Diseño UML: Clases y Relaciones

🧱 Fragmento UML

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

🧠 ¿Qué aprendiste hoy?

🎯 ¿Qué aprenderás en esta parte?

📌 ¿Qué es UML?

🧱 Estructura de una clase en UML

🧩 Ejemplo simple en UML

🧱 ¿Qué es `pip`?

🗂 ¿Qué es un archivo `requirements.txt`?

🧱 ¿Qué es `unittest`?

🧱 ¿Qué es `assert`?

✅ Ventajas de usar `assert`

🔐 Personalizar errores con `try-except`

📂 Cargar usuarios desde el archivo `.json`