Reestructuración de Código con Módulos en Python y Principios SOLID

Clase 13 de 27 • Curso de Patrones de Diseño y SOLID en Python

Resumen

Los patrones de diseño son una herramienta poderosa en el desarrollo de software que permite resolver problemas comunes de una manera eficiente y reutilizable. En esta introducción, exploraremos qué son, por qué existen y cuáles son los principales tipos de patrones, como los creacionales, estructurales y de comportamiento, junto con ejemplos prácticos que te permitirán comprender su utilidad en la creación de software de calidad.

¿Qué son los patrones de diseño?

Los patrones de diseño son soluciones reutilizables para problemas recurrentes en el desarrollo de software. Se pueden comparar con recetas en el mundo culinario: cada patrón es una guía aplicable a ciertos escenarios o problemas. Al igual que las recetas se ajustan a ciertos ingredientes, los patrones de diseño se aplican en situaciones específicas dentro de la programación.

¿Por qué existen los patrones de diseño?

Estos patrones surgen de la experiencia acumulada de los autores del libro Design Patterns, conocido como “The Gang of Four”. A través de su trabajo, recopilaron soluciones que ayudan a crear código mantenible y reutilizable, lo que es crucial en el desarrollo colaborativo. Al adoptar estos patrones, los desarrolladores pueden comunicarse de manera más efectiva, utilizando un lenguaje común que simplifica el intercambio de ideas y la colaboración en revisiones de código.

¿Cuáles son las categorías de los patrones de diseño?

Existen tres categorías principales:

Patrones creacionales: Se centran en la creación de instancias de objetos. Son útiles cuando la creación de un objeto es compleja o tiene muchas dependencias. Ejemplos incluyen:
- Singleton
- Factory Method
- Abstract Factory
- Builder
- Prototype
Patrones estructurales: Se enfocan en la composición de clases y objetos para crear estructuras eficientes. Permiten organizar clases de manera óptima. Algunos ejemplos son:
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
Patrones de comportamiento: Ayudan a mejorar la comunicación y asignación de responsabilidades entre objetos, resolviendo interacciones complejas entre clases. Ejemplos incluyen:
- Observer
- Strategy
- Command
- Iterator
- Mediator
- State
- Visitor

¿Cómo se aplican los patrones de diseño en la industria?

En proyectos reales, no es necesario usar todos los patrones de diseño. La clave está en seleccionar aquellos que mejor se adapten al contexto específico del proyecto. En este curso, se verán algunos de los patrones más utilizados en la industria, aplicables al tipo de software que desarrollaremos, y serán clave para resolver problemas comunes de manera eficiente.

juan esteban colcombet

student•

Perdon, no entendi, en donde esta el proyecto open source para implementar la reestructuracion que dice Eduardo al final del video? gracias

Jose Enrique Marquez

student•

No estoy seguro si somos 2 que no entendimos completamente, pero yo tampoco encontre lo que se supone que debe estar en recursos.

Oscar Barajas Tavares

Team Platzi•

Acá tienen un proyecto en Python que puede ser reestructurado: https://github.com/gndx/youTubeTranscribe

Emilio Nicolás Mendoza Patti

student•

Difinitvamente es una lucha constante seguir al profesor, pero ya teniendo el codigo mas avanzado en los recursos, deberian poner como recurso un github inicial con el codigo base para que se pueda seguir la clase.

Ray Trápala

student•

La organización de tu código es crucial y debe adaptarse al contexto y necesidades del proyecto. Tu propuesta de crear un paquete por cada responsabilidad y un paquete para las implementaciones es válida y favorece la claridad y mantenibilidad.

Protocolo y paquetes: Crear un paquete raíz con protocolos y otro para las implementaciones es una buena práctica. Así, se facilita el entendimiento y se separan las preocupaciones.
Estructuras como pydantic.BaseModel: Pueden considerarse modelos, pero también pueden formar parte de un paquete de validadores. Si decides crear un paquete específico, un nombre apropiado podría ser schemas o models, dependiendo de su uso.

Recuerda que la consistencia en la nomenclatura y la organización facilitará el trabajo en equipo y la escalabilidad del proyecto.

Ray Trápala

student•

me gustó la respuesta de la IA. buena esa Platzi.

Oscar Barajas Tavares

Team Platzi•

Se vuelve un aliado para ir a complementar tu aprendizaje.

Kevin Gonzalez

student•

Me queda la duda de cómo decide si un payment debe usar sms o email para notificar cuando tiene dos Notifier (clases email o sms) y solo crea uno de esos objetos ¿En qué parte de la lógica está que se crea uno o el otro objeto dependiendo del tipo de dato que recibió?

En anteriores clases, vi que creaba dos servicios distintos, pero era el programador quien decidía eso y no se lo hacía dinámicamente.

Al final de la reestructuración no ejecutó nuevamente el código. Me deja mucho que desear el curso hasta este punto.

Alejandro Sanchez

student•

Las clases de bajo nivel son aquellas que tienen una responsabilidad específica y se encargan de realizar tareas concretas dentro de un sistema. En el contexto de la reestructuración del proyecto de pagos, las clases de bajo nivel incluyen validadores, procesadores de pago y loggers. Estas clases son utilizadas por la clase de alto nivel (PaymentService), permitiendo una mayor modularidad y facilidad de mantenimiento en el código. Esto se alinea con los principios SOLID, donde cada clase tiene una única responsabilidad y se puede modificar sin afectar al sistema completo.

Mario Alexander Vargas Celis

student•

Reestructurar un proyecto en Python implica organizar su estructura de archivos y carpetas para que sea modular, mantenible y escalable, especialmente en proyectos complejos. Una estructura bien organizada facilita el desarrollo, las pruebas, la colaboración en equipo y la integración de herramientas de CI/CD.

Aquí tienes una guía para estructurar un proyecto en Python, especialmente útil para aplicaciones de tamaño medio a grande.

---

### Estructura Común para un Proyecto en Python

Imaginemos que tienes un proyecto llamado my\_project. La estructura típica podría verse así:


my\_project/

│

├── my\_project/              # Paquete principal de la aplicación

│   ├── \_\_init\_\_.py          # Marca este directorio como un paquete Python

│   ├── main.py              # Archivo principal para ejecutar la aplicación

│   ├── config.py            # Configuración de la aplicación

│   ├── controllers/         # Lógica de controladores o lógica de negocio

│   │   ├── \_\_init\_\_.py

│   │   └── user\_controller.py

│   ├── models/              # Modelos y clases de datos

│   │   ├── \_\_init\_\_.py

│   │   └── user.py

│   ├── services/            # Servicios o lógica de negocio

│   │   ├── \_\_init\_\_.py

│   │   └── user\_service.py

│   ├── repositories/        # Capa de acceso a datos

│   │   ├── \_\_init\_\_.py

│   │   └── user\_repository.py

│   ├── utils/               # Utilidades y funciones auxiliares

│   │   ├── \_\_init\_\_.py

│   │   └── helpers.py

│   └── schemas/             # Definición de esquemas o validaciones

│       ├── \_\_init\_\_.py

│       └── user\_schema.py

│

├── tests/                   # Pruebas unitarias y funcionales

│   ├── \_\_init\_\_.py

│   ├── test\_main.py         # Pruebas de integración para main.py

│   ├── controllers/         # Pruebas de controladores

│   ├── models/              # Pruebas de modelos

│   ├── services/            # Pruebas de servicios

│   └── repositories/        # Pruebas de acceso a datos

│

├── scripts/                 # Scripts de gestión (deploy, migraciones)

│   └── run\_migration.py

│

├── .env                     # Variables de entorno (NO subir a control de versiones)

├── requirements.txt         # Dependencias del proyecto

├── README.md                # Documentación general del proyecto

├── .gitignore               # Archivos y carpetas ignoradas por git

└── setup.py                 # Script de instalación para pip

### Explicación de Cada Directorio y Archivo

- **my_project/**: Este es el paquete principal de tu aplicación, que incluye la mayor parte de la lógica y componentes del proyecto.

- **\_\_init\_\_.py**: Marca el directorio como un paquete. Si usas namespaces, puedes añadir configuraciones básicas.

- **main.py**: Punto de entrada de la aplicación. En una aplicación web, aquí podría residir el servidor principal, mientras que en una CLI se definiría el comando principal.

- **config.py**: Define configuraciones globales (puedes cargar variables de .env o definir configuraciones específicas para cada entorno).

- **controladores (controllers/)**: Aquí reside la lógica de los controladores, que gestionan la lógica de flujo de la aplicación. Para una API, por ejemplo, este directorio puede incluir controladores para diferentes endpoints.

- **modelos (models/)**: Define la estructura de datos (o modelos ORM, si usas una base de datos). Cada modelo representa una entidad o clase de datos.

- **servicios (services/)**: Contiene la lógica de negocio. Aquí colocas las operaciones específicas y servicios que actúan sobre los datos y no necesariamente dependen del flujo del usuario.

- **repositorios (repositories/)**: Capa de acceso a datos que interactúa con la base de datos o con APIs externas. Permite la separación del almacenamiento de datos y la lógica de negocio.

- **utilidades (utils/)**: Funciones auxiliares que pueden ser usadas en distintas partes del proyecto (validaciones, formateo de datos, etc.).

- **esquemas (schemas/)**: Definiciones de esquemas o validaciones de datos (por ejemplo, usando librerías como pydantic o marshmallow). Sirve para definir y validar los datos que entran o salen del sistema.

- **tests/**: Directorio para pruebas unitarias, funcionales e integradas. Organizado de forma similar al proyecto principal para encontrar y estructurar mejor las pruebas de cada módulo.

- **scripts/**: Contiene scripts auxiliares, como scripts de migraciones, herramientas de despliegue, o utilidades de mantenimiento del sistema.

- **.env**: Archivo para variables de entorno, como claves API o configuraciones específicas del entorno, que no deben subirse al repositorio.

- **requirements.txt**: Lista de dependencias del proyecto, necesaria para instalar las librerías con pip.

- **README.md**: Documentación general del proyecto. Aquí puedes describir el propósito del proyecto, instrucciones de instalación y guías de uso.

- **.gitignore**: Archivo de configuración para ignorar archivos específicos en el control de versiones (por ejemplo, .env, archivos de caché, etc.).

- **setup.py**: Script de configuración para la instalación del paquete si estás planeando distribuir el proyecto como una biblioteca o una herramienta instalable.

### Consejos Adicionales

1. **Usa herramientas de linting y formateo**: Utiliza flake8 o pylint para asegurar la calidad del código, y black o autopep8 para mantener el formato del código.

2. **Pruebas automatizadas**: Configura tus pruebas con pytest o unittest para que corran automáticamente en un servidor de CI/CD (por ejemplo, usando GitHub Actions o GitLab CI).

3. **Documentación**: Es recomendable documentar tanto el código como el README.md, e incluso usar docstrings y herramientas como Sphinx si el proyecto es grande.

4. **Configuración flexible**: En config.py, carga variables de entorno usando una librería como dotenv para facilitar el cambio de entornos (producción, desarrollo, etc.).

### Ejemplo de Código para config.py


import os

from dotenv import load\_dotenv



\# Cargar variables de entorno del archivo .env

load\_dotenv()



class Config:

&#x20;   DEBUG = os.getenv("DEBUG", "False") == "True"

&#x20;   DATABASE\_URL = os.getenv("DATABASE\_URL")

&#x20;   SECRET\_KEY = os.getenv("SECRET\_KEY", "default\_secret\_key")

### Ejemplo de main.py con Configuración de Entrada


from my\_project.config import Config

from my\_project.controllers.user\_controller import UserController



def main():

&#x20;   print("Starting application...")

&#x20;   user\_controller = UserController()

&#x20;   user\_controller.run()



if \_\_name\_\_ == "\_\_main\_\_":

&#x20;   main()

### Beneficios de una Buena Estructura de Proyecto

- **Mantenibilidad**: La separación de responsabilidades hace que el código sea más fácil de modificar y mantener.

- **Escalabilidad**: Una estructura bien organizada permite agregar nuevas funcionalidades de manera ordenada.

- **Colaboración**: Facilita el trabajo en equipo, ya que cada miembro puede trabajar en un módulo sin interferir en otros.

- **Pruebas**: Las pruebas se integran de forma natural en la estructura, permitiendo que cada módulo tenga sus pruebas específicas.

Organizar y estructurar bien un proyecto en Python es esencial para el éxito a largo plazo. Mantener estas buenas prácticas hará que el desarrollo sea más eficiente y sostenible.

Sebastian Alejandro Gómez Ardila

student•

La carpeta payment_service se organiza en módulos que representan distintos contextos, como:

Commons: Información de contacto, datos de cliente y datos de pago.
Notificadores: Protocolo y clases para notificaciones (email y SMS).
Loggers: Clase para el registro de transacciones.
Validadores: Clases para validar datos de cliente y pago.
Procesadores: Protocolos y clases que implementan la lógica de pagos, como Stripe.

Cada contexto tiene su propia carpeta y las clases se importan en el archivo service.py para mantener la estructura limpia y escalable.