Método de construcción: patrones de diseño de Python

Builder Method es un patrón de diseño de creación que tiene como objetivo «separar la construcción de un objeto complejo de su representación para que el mismo proceso de construcción pueda crear diferentes representaciones». Te permite construir objetos complejos paso a paso. Aquí, usando el mismo código de construcción, podemos producir fácilmente diferentes tipos y representaciones del objeto.
Básicamente está diseñado para proporcionar flexibilidad a las soluciones a varios problemas de creación de objetos en la programación orientada a objetos.
 

Diagrama UML del patrón de diseño del constructor

Método constructor

Problema sin usar el Método Builder:

Imagina que quieres unirte a uno de los lotes de élite de GeeksforGeeks . Entonces, irá allí y preguntará sobre la estructura de tarifas, los horarios disponibles y los lotes sobre el curso al que desea unirse. Después de mirar el sistema, le informarán sobre los cursos, sus estructuras de tarifas, los horarios disponibles y los lotes. ¡Eso es todo! (¡No! Aún no hemos terminado porque somos buenos desarrolladores).
Nuestro principal propósito es diseñar el sistema flexible, confiable, organizado y lubricante. lo que harán los desarrolladores sin experiencia es que crearán una clase separada y única para todos y cada uno de los cursos proporcionados por GeeksforGeeks. Luego, crearán instancias de objetos separadas para todas y cada una de las clases, aunque no siempre se requiere. El principal problema surgirá cuando GeeksforGeeks inicie nuevos cursos y los desarrolladores también tengan que agregar nuevas clases porque su código no es muy flexible.
 

método-constructor-de-problemas

Nota: El siguiente código se escribe sin utilizar el método Builder.
 

# concrete course
class DSA():
 
    """Class for Data Structures and Algorithms"""
 
    def Fee(self):
        self.fee = 8000
 
    def available_batches(self):
        self.batches = 5
 
    def __str__(self):
        return "DSA"
 
# concrete course
class SDE():
 
    """Class for Software development Engineer"""
 
    def Fee(self):
        self.fee = 10000
 
    def available_batches(self):
        self.batches = 4
 
    def __str__(self):
        return "SDE"
 
# concrete course
class STL():
 
    """class for Standard Template Library of C++"""
 
    def Fee(self):
        self.fee = 5000
 
    def available_batches(self):
        self.batches = 7
 
    def __str__(self):
        return "STL"
 
 
# main method
if __name__ == "__main__":
 
    sde = SDE()   # object for SDE
    dsa = DSA()   # object for DSA
    stl = STL()   # object for STL
 
    print(f'Name of Course: {sde} and its Fee: {sde.fee}')
    print(f'Name of Course: {stl} and its Fee: {stl.fee}')
    print(f'Name of Course: {dsa} and its Fee: {dsa.fee}')

Solución por el método del constructor:

Nuestro producto final final debe ser cualquier curso de GeeksforGeeks. Puede ser SDE, STL o DSA. Tenemos que pasar por muchos pasos antes de elegir un curso en particular, como encontrar detalles sobre los cursos, el plan de estudios, la estructura de tarifas, los horarios y los lotes. Aquí, usando el mismo proceso, podemos seleccionar diferentes cursos disponibles en GeeksforGeeks . Ese es el beneficio de usar el Patrón constructor.
 

método de creación de soluciones

# Abstract course
class Course:
 
    def __init__(self):
        self.Fee()
        self.available_batches()
 
    def Fee(self):
        raise NotImplementedError
 
    def available_batches(self):
        raise NotImplementedError
 
    def __repr__(self):
        return 'Fee : {0.fee} | Batches Available : {0.batches}'.format(self)
 
# concrete course
class DSA(Course):
 
    """Class for Data Structures and Algorithms"""
 
    def Fee(self):
        self.fee = 8000
 
    def available_batches(self):
        self.batches = 5
 
    def __str__(self):
        return "DSA"
 
# concrete course
class SDE(Course):
 
    """Class for Software Development Engineer"""
 
    def Fee(self):
        self.fee = 10000
 
    def available_batches(self):
        self.batches = 4
 
    def __str__(self):
        return "SDE"
 
# concrete course
class STL(Course):
 
    """Class for Standard Template Library"""
 
    def Fee(self):
        self.fee = 5000
 
    def available_batches(self):
        self.batches = 7
 
    def __str__(self):
        return "STL"
 
# Complex Course
class ComplexCourse:
 
    def __repr__(self):
        return 'Fee : {0.fee} | available_batches: {0.batches}'.format(self)
 
# Complex course
class Complexcourse(ComplexCourse):
 
    def Fee(self):
        self.fee = 7000
 
    def available_batches(self):
        self.batches = 6
 
# construct course
def construct_course(cls):
 
    course = cls()
    course.Fee()
    course.available_batches()
 
    return course    # return the course object
 
# main method
if __name__ == "__main__":
 
    dsa = DSA()  # object for DSA course
    sde = SDE()  # object for SDE course
    stl = STL()  # object for STL course
 
    complex_course = construct_course(Complexcourse)
    print(complex_course)

Diagrama de clase general para el método de patrón de constructor:

Diagrama de clase general para el método de construcción

Ventajas de usar el Método Builder:

1. Reutilización: al hacer las diversas representaciones de los productos, también podemos usar el mismo código de construcción para otras representaciones.
2. Principio de responsabilidad única: podemos separar tanto la lógica empresarial como el código de construcción complejo entre sí.
3. Construcción del objeto: Aquí construimos nuestro objeto paso a paso, diferimos pasos de construcción o ejecutamos pasos recursivamente.

Desventajas de usar el método Builder:

1. Aumenta la complejidad del código : aumenta la complejidad de nuestro código, porque el patrón del constructor requiere la creación de varias clases nuevas.
2. Mutabilidad: Requiere que la clase de constructor sea mutable .
3. Inicialización: no se garantiza que los miembros de datos de la clase se inicialicen.

Aplicabilidad:

1. Construcción de objetos complejos: el método Builder le permite construir los productos paso a paso. Incluso, podemos aplazar la ejecución de algunos pasos sin romper el producto final. Para crear un árbol de objetos, es útil llamar a los pasos de forma recursiva. Evita que el código del cliente obtenga los datos incompletos porque no permite la exposición de un objeto sin terminar.
2. Difieren por representaciones: el patrón Builder es aplicable cuando la construcción de varias representaciones del producto involucra pasos similares que difieren solo en los detalles. La interfaz del constructor base se utiliza para definir todos los pasos de construcción, mientras que estos pasos son implementados por constructores concretos.

  
Leer más: Método Builder Design en C++