Patrón Factory Pattern en Python: Creación de Objetos Dinámicos

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

Resumen

¿Qué es el patrón creacional Factory Pattern?

El Factory Pattern es uno de los patrones de diseño más importantes en el desarrollo de software, y su principal característica es su capacidad para crear objetos sin necesidad de especificar la clase exacta. Esto se logra mediante el uso de interfaces, abstracciones o protocolos. Este patrón encapsula la lógica de creación, centralizando las decisiones sobre qué clases crear y cómo hacerlo, permitiendo así una mayor flexibilidad y escalabilidad en el sistema.

¿Cómo funciona el Factory Pattern?

La esencia del Factory Pattern reside en la creación de una clase llamada 'Factory', la cual contiene un método que instancia y devuelve objetos basados en ciertos parámetros. Al aplicar este patrón, el lugar donde se toman las decisiones de creación se centraliza, lo que facilita mantener y escalar el sistema.

Por ejemplo, en un diagrama de clases se podría visualizar una clase de alto nivel llamada PaymentService, que interactúa con PaymentFactory. Esta última tiene un método GetProcessor que decide cuál de los procesadores de pago usar, basándose en un tipo específico pasado como parámetro. Así, PaymentFactory centraliza la lógica de decidir cuál procesador utilizar, permitiendo fácilmente integrar nuevos procesadores en el futuro.

¿Cuándo es adecuado aplicar este patrón?

El Factory Pattern se convierte en una excelente opción en los siguientes escenarios:

Cuando hay múltiples clases que comparten una interfaz común. Esto es especialmente útil en sistemas donde se requiere el uso de distintas estrategias para resolver problemáticas similares.
Cuando la creación de objetos requiere una compleja lógica de decisión. Si hay muchas variables para decidir qué clase seleccionar, este patrón ayuda a simplificar el proceso y establecer un control centralizado.

Además, funciona muy bien junto al patrón Strategy, facilitando la selección de estrategias adecuadas para cada caso de uso.

¿Cómo implementarlo efectivamente?

Para implementar el Factory Pattern, sigue estos pasos:

Define interfaces comunes: Asegúrate de que todas las posibles clases a instanciar implementen una interfaz o abstracción común.
Crea la clase Factory: Desarrolla una clase que tenga un método encargado de recibir parámetros. Este método debe determinar qué clase instanciar.
Utiliza el Factory en el código cliente: Cada vez que necesites crear una instancia, utiliza el Factory para obtener el objeto correcto.

Así, al integrar el Factory Pattern, logramos crear aplicaciones más flexibles y escalables, permitiendo modificar e integrar nuevas funcionalidades sin alterar la estructura fundamental del sistema.

Conozcan el Factory Pattern y experimenten su potencial. Esta práctica es crucial para cualquier desarrollador que quiera construir sistemas robustos y flexibles. ¡Sigue aprendiendo y aplicando estos patrones en tus proyectos!

Mario Alexander Vargas Celis

student•

El Patrón Factory es un patrón de diseño creacional que permite crear objetos sin especificar la clase exacta del objeto que se va a instanciar. Este patrón utiliza interfaces o clases abstractas para encapsular la lógica de creación, facilitando así la flexibilidad y la escalabilidad del código. Se utiliza especialmente cuando hay múltiples clases que comparten una interfaz común y se requiere decidir cuál de ellas crear en tiempo de ejecución. Esto centraliza la lógica de creación, haciendo que el sistema sea más mantenible y extensible.

Franco Manca

student•

El patrón Factory en Python se caracteriza por:

Abstracción: Crea objetos sin especificar la clase exacta, utilizando interfaces o abstracciones.
Encapsulamiento: Centraliza la lógica de creación de objetos, simplificando la instancia de clases.
Flexibilidad: Permite añadir nuevos tipos de objetos sin modificar el código existente.

Cuándo aplicarlo:

Cuando hay múltiples clases que comparten una interfaz.
Cuando la creación de objetos requiere lógica compleja.

Cómo aplicarlo:

Crea una clase Factory con un método que instancie objetos basados en parámetros. Usa el Factory donde se requieran instancias, facilitando cambios futuros.

Mario Alexander Vargas Celis

student•

El **Patrón Factory** es un patrón de diseño creacional que proporciona una manera de crear objetos sin exponer la lógica de creación al cliente. En su lugar, el cliente utiliza un método común para crear las instancias necesarias. Este patrón es útil cuando la creación de objetos es compleja o depende de condiciones específicas.

### Conceptos Clave del Patrón Factory

1. **Encapsulación**: La lógica de creación de objetos está encapsulada en un método, función o clase específica.

2. **Simplicidad para el Cliente**: El cliente no necesita conocer los detalles sobre qué clase exacta está siendo instanciada.

3. **Extensibilidad**: Es fácil añadir nuevas clases sin modificar el código del cliente.

### Tipos de Patrón Factory

1. **Simple Factory**: Tiene un único método para crear instancias de diferentes clases.

2. **Factory Method**: Define una interfaz para crear objetos, dejando las subclases responsables de definir qué clase instanciar.

3. **Abstract Factory**: Proporciona una interfaz para crear familias de objetos relacionados o dependientes.

---

### Implementación del Patrón Factory en Python

Supongamos que estamos desarrollando un sistema para generar notificaciones (correo electrónico, SMS y push). Utilizaremos una **Simple Factory** para gestionar estas instancias.

#### Paso 1: Crear una Interfaz Común

Definimos una clase base que todas las notificaciones implementarán.


from abc import ABC, abstractmethod



class Notification(ABC):

&#x20;   @abstractmethod

&#x20;   def notify(self, message: str):

&#x20;       """Envía una notificación con el mensaje dado."""

&#x20;       pass

#### Paso 2: Implementar Clases Concretas

Creamos clases específicas para cada tipo de notificación.


class EmailNotification(Notification):

&#x20;   def notify(self, message: str):

&#x20;       print(f"Enviando correo electrónico: {message}")



class SMSNotification(Notification):

&#x20;   def notify(self, message: str):

&#x20;       print(f"Enviando SMS: {message}")



class PushNotification(Notification):

&#x20;   def notify(self, message: str):

&#x20;       print(f"Enviando notificación push: {message}")

#### Paso 3: Crear la Fábrica

La fábrica centraliza la lógica para instanciar las notificaciones según el tipo solicitado.


class NotificationFactory:

&#x20;   @staticmethod

&#x20;   def create\_notification(notification\_type: str) -> Notification:

&#x20;       if notification\_type == "email":

&#x20;           return EmailNotification()

&#x20;       elif notification\_type == "sms":

&#x20;           return SMSNotification()

&#x20;       elif notification\_type == "push":

&#x20;           return PushNotification()

&#x20;       else:

&#x20;           raise ValueError(f"Tipo de notificación desconocido: {notification\_type}")

#### Paso 4: Usar el Patrón Factory

Ahora podemos crear notificaciones sin preocuparnos por la lógica de instanciación.


\# Crear diferentes notificaciones usando la fábrica

notification1 = NotificationFactory.create\_notification("email")

notification1.notify("¡Hola! Este es un correo electrónico.")



notification2 = NotificationFactory.create\_notification("sms")

notification2.notify("¡Hola! Este es un SMS.")



notification3 = NotificationFactory.create\_notification("push")

notification3.notify("¡Hola! Esta es una notificación push.")

---

### Ventajas del Patrón Factory

1. **Simplicidad para el Cliente**: El cliente no necesita preocuparse por la lógica de creación de objetos.

2. **Centralización**: La lógica de creación se mantiene en un solo lugar, haciendo que el código sea más fácil de mantener.

3. **Extensibilidad**: Es sencillo añadir nuevas clases de notificación (o cualquier tipo de objeto) sin modificar la lógica existente en el cliente.

4. **Cumplimiento del Principio Abierto/Cerrado (OCP)**: Podemos extender el sistema con nuevos tipos de objetos sin cambiar la fábrica.

---

### Consideraciones

1. **Acoplamiento**: Si la fábrica crece demasiado, puede volverse un punto de acoplamiento fuerte.

2. **Complejidad Inicial**: Para problemas simples, el uso de una fábrica puede parecer innecesario.

---

### Variación: Usar Diccionarios en lugar de Condicionales

Podemos simplificar la implementación de la fábrica utilizando un diccionario para mapear tipos de notificaciones a sus clases concretas.


class NotificationFactory:

&#x20;   \_notification\_classes = {

&#x20;       "email": EmailNotification,

&#x20;       "sms": SMSNotification,

&#x20;       "push": PushNotification,

&#x20;   }



&#x20;   @staticmethod

&#x20;   def create\_notification(notification\_type: str) -> Notification:

&#x20;       notification\_class = NotificationFactory.\_notification\_classes.get(notification\_type)

&#x20;       if not notification\_class:

&#x20;           raise ValueError(f"Tipo de notificación desconocido: {notification\_type}")

&#x20;       return notification\_class()

Esto elimina los condicionales, haciendo que el código sea más limpio y fácil de mantener.

---

### Conclusión

El **Patrón Factory** en Python es una herramienta poderosa para gestionar la creación de objetos, especialmente cuando el proceso de instanciación es complejo o depende de condiciones dinámicas. Este patrón mejora la organización y extensibilidad del código, promoviendo prácticas de diseño robustas.

Ronaldo Jiménez

student•


from abc import ABC, abstractmethod

# Producto abstracto
class Transporte(ABC):
    @abstractmethod
    def mover(self):
        pass

# Productos concretos
class Coche(Transporte):
    def mover(self):
        return "El coche se está moviendo por carretera"

class Bicicleta(Transporte):
    def mover(self):
        return "La bicicleta se está moviendo por el carril bici"

# Clase creadora abstracta
class CreadorTransporte(ABC):
    @abstractmethod
    def crear_transporte(self):
        pass

# Creadores concretos
class CreadorCoche(CreadorTransporte):
    def crear_transporte(self):
        return Coche()

class CreadorBicicleta(CreadorTransporte):
    def crear_transporte(self):
        return Bicicleta()

# Uso del patrón Factory Method
def cliente(creador: CreadorTransporte):
    transporte = creador.crear_transporte()
    print(transporte.mover())

# Crear un coche
cliente(CreadorCoche())  # Salida: "El coche se está moviendo por carretera"

# Crear una bicicleta
cliente(CreadorBicicleta())  # Salida: "La bicicleta se está moviendo por el carril bici"

edgardo ponce

student•

falto agregar la documentación que se fue agregando a todos las otras clases.

Ray Trápala

student•

No sé si puede dcirse que lo aplique pero cuando tengo esos casos tengo una clase factory que recibe, por decir, el nombre de un exchange (mi proyecto es un bot de trading) y este "factory" busca en un diccionario que tengo donde la llave es el nombre del exchange y el valor la referencia de la clase y ya crea el objeto y lo retorna

Eduardo José Álvarez

Team Platzi•

sí, es una forma de implementar un patrón Factory. La lógica para decidir qué implementación está representada por un diccionario, totalmente válido

Bryann Andrei Valderrama Avila

student•

¿Este es el mismo Abstract Factory?

Platzi

student•

Factory Pattern y Abstract Factory son diferentes. En esta clase se abordó el Factory Pattern, no el Abstract Factory.