Diferentes formas de implementar el patrón Python Builder

1. El Patrón Constructor, Su Importancia y Funcionamiento
2. Diferentes formas de implementar el patrón Builder en Python
3. Ventajas y desventajas del patrón Builder en Python

El patrón Builder es un patrón que permite separar la creación de un objeto de su representación. Este patrón puede crear y configurar objetos complejos sin herencia, lo cual es un enfoque poderoso pero inflexible.

El patrón de construcción también se puede utilizar para proporcionar diferentes implementaciones de una clase en tiempo de ejecución o para permitir que los usuarios construyan nuevos objetos sin tener acceso al código fuente.

Este tutorial educa sobre los patrones de construcción y cómo funcionan. También demuestra diferentes formas de implementar patrones de construcción de Python.

El Patrón Constructor, Su Importancia y Funcionamiento

El patrón constructor es el patrón de diseño de software que permite crear paso a paso la construcción de objetos complejos, proporcionando un nuevo nivel de detalle o funcionalidad.

Este patrón se usa a menudo en el desarrollo de software, donde se deben combinar diferentes componentes de software para formar un sistema completo.

El patrón de construcción se puede utilizar para crear cualquier cosa, desde objetos simples, como una mesa o una silla, hasta sistemas más complejos, como una computadora o un avión. También es útil para crear objetos que deben crearse en un orden específico.

La biblioteca estándar de Python proporciona un módulo llamado constructor, lo que facilita el uso del patrón Builder. El módulo constructor proporciona dos clases, el Constructor y el Director, que trabajan juntos para crear objetos.

La clase Constructor es responsable de crear las partes del objeto, y la clase Director se usa para ensamblar los componentes en el objeto final.

Para usar el patrón Constructor, primero crea un objeto Constructor, que usa para crear las partes del objeto. Luego crea un objeto Director, que usa para ensamblar las piezas en el objeto final.

Finalmente, puede llamar al método build() en el objeto Director, que devuelve el objeto final.

Diferentes formas de implementar el patrón Builder en Python

Hay dos métodos para implementar el patrón Builder en Python:

1. El método __init__
2. El método __nuevo__

Utilice el método __init__

El método __init__ es la forma más común de implementar el patrón Builder en Python. Se llama cuando se crea el objeto, lo que le permite establecer los valores de sus atributos.

Usa el método __nuevo__

El método __new__ es menos común pero más poderoso. El método __new__ se llama cuando se crea la clase, lo que le permite crear el objeto en sí.

Significa que puede controlar cómo se crea el objeto e incluso crear objetos que no sean del mismo tipo que la clase.

Ventajas y desventajas del patrón Builder en Python

Hay algunas ventajas de los patrones de construcción que se enumeran a continuación:

• La ventaja esencial del patrón constructor es que permite crear objetos complejos paso a paso, proporcionando un nuevo nivel de detalle o funcionalidad.
• Esto hace que la creación de objetos complejos sea mucho más simple y eficiente.
• El patrón constructor también es ventajoso porque permite un alto grado de flexibilidad, ya que diferentes constructores pueden crear diferentes tipos de objetos.

También hay algunas desventajas en el uso del patrón de construcción.

• Una es que la creación de un objeto puede llevar bastante tiempo, ya que cada paso debe realizarse en orden.
• Otra desventaja es que el patrón del constructor puede ser bastante complejo y requiere mucho código para ser escrito.

Ejemplo de código:

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any


class Builder(ABC):
    @property
    @abstractmethod
    def product(self) -> None:
        pass

    @abstractmethod
    def produce_a(self) -> None:
        pass

    """
    This class will provide specific working of the building steps by using the builder interface.
    """


class ConcreteBuilder1(Builder):
    def __init__(self) -> None:
        """This fresh builder instance will contain a blank product object, which is
        used in further assembly.
        """
        self.reset()

    def reset(self) -> None:
        self._product = Product1()

    @property
    def product(self) -> Product1:

        product = self._product
        self.reset()
        return product

    def produce_a(self) -> None:
        self._product.add("PartA")


class Product1:
    """
    When your products are complex and demand extensive configuration, it's possible to use the Builder pattern only.
    """

    def __init__(self) -> None:
        self.parts = []

    def add(self, part: Any) -> None:
        self.parts.append(part)

    def list_parts(self) -> None:
        print(f"The Product parts: {', '.join(self.parts)}", end="")


class Director:
    """
    The client can control builders directly, so the Director class is
     optional. In this case, the Director is only responsible for executing the building steps in a specific sequence.
    """

    def __init__(self) -> None:
        self._builder = None

    @property
    def builder(self) -> Builder:
        return self._builder
        """
    The Director can construct several product variations using the same
    building steps.
    """

    @builder.setter
    def builder(self, builder: Builder) -> None:
        self._builder = builder

    def build_minimal_viable_product(self) -> None:
        self.builder.produce_a()

    def build_full_featured_product(self) -> None:
        self.builder.produce_a()


if __name__ == "__main__":

    director = Director()
    builder = ConcreteBuilder1()
    director.builder = builder

    print("Our Standard primary product:")
    director.build_minimal_viable_product()
    builder.product.list_parts()

    print("\n")

    print("Our Standard full-featured product:")
    director.build_full_featured_product()
    builder.product.list_parts()

    print("\n")
    # We can also use the Builder pattern without a Director class.
    print("Our Custom product: ")
    builder.produce_a()
    builder.product.list_parts()

Producción :

Our Standard primary product:
The Product parts: PartA

Our Standard full-featured product:
The Product parts: PartA

Our Custom product: 
The Product parts: PartA

Recuerde que el patrón Builder también es un patrón de diseño que ayuda a construir objetos complejos al separar la construcción y la representación. Esta separación permite realizar diferentes representaciones a partir de un mismo proceso de construcción.