Builder Pattern: construcción paso a paso

Curso de Patrones de Diseño y SOLID en Python

Contenido del curso

Patrones de Diseño y Principios SOLID

1
Patrones de diseño y SOLID en Python
02:07 min

Principios SOLID

Reestructuración del proyecto

13
Reestructuración con módulos de Python y SOLID
13:32 min

Patrones de Diseño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:001:28

Builder Pattern: construcción paso a paso

Curso de Patrones de Diseño y SOLID en Python

Clase 21 de 27

Clase 21 / 27

Recursos

Domina el Builder Pattern con una guía clara y práctica: separa la construcción de la representación del objeto para crear variantes complejas con orden. Aquí verás cómo este patrón de diseño creacional ofrece una interfaz paso a paso, cuándo conviene aplicarlo y cómo estructurarlo con métodos por atributo y un método build.

Builder Pattern: construcción paso a paso para objetos complejos

¿Qué es el builder pattern y qué resuelve?

El Builder Pattern es un patrón de diseño creacional que separa la construcción de la representación del objeto. Permite definir una interfaz de creación paso a paso y facilita variantes del mismo objeto sin complicar la lógica.

En el diagrama descrito, la clase Builder construye un objeto de tipo producto con tres atributos: parte A, parte B y parte C. Para ello, se define un método por cada atributo y un método build que ensambla el resultado final.

¿Cómo separa la construcción de la representación?

La construcción se orquesta en una clase independiente llamada Builder.
La representación final queda encapsulada en la clase producto.
La interfaz de creación es paso a paso, clara y predecible.

¿Qué rol cumplen los métodos por atributo?

Cada método configura una parte: parte A, parte B, parte C.
Se pueden encadenar pasos sin exponer los detalles internos.
El método build une todos los parámetros y devuelve el objeto completo.

¿Cuándo aplicar este patrón de diseño creacional?

Cuando la creación de un objeto complejo requiere múltiples pasos y empieza a ser difícil de mantener, este patrón aporta orden y claridad. Además, es ideal cuando necesitas separar la construcción de la representación final.

Cuando un objeto necesita varios pasos de configuración.
Cuando la clase se volvió compleja y requiere simplificación con un nuevo paradigma.
Cuando es clave separar el proceso de construcción de su resultado final.
Cuando se deben crear diferentes variantes del mismo objeto sin duplicar lógica.

¿Cómo implementarlo paso a paso?

La implementación se centra en mover la lógica de construcción a una clase Builder y ofrecer una interfaz clara por atributo, cerrando con build para ensamblar el objeto final.

Separar la construcción en una clase llamada Builder.
Crear métodos específicos por cada atributo del producto: parte A, parte B, parte C.
Definir el método build para unir los parámetros indicados en los pasos y construir la clase final.
Mantener la interfaz de creación paso a paso para legibilidad y mantenimiento.
Favorecer variantes del producto sin alterar su representación.

¿Has aplicado el patrón Builder en algún proyecto profesional? Comparte tu experiencia en los comentarios y qué retos resolviste con este enfoque.

    def \_\_str\_\_(self):        return f"Casa con {self.habitaciones} habitaciones, hecha de {self.material} y techo {self.techo}."```
\#### Paso 2: Crear el Builder
Define una clase `CasaBuilder` que contiene métodos para configurar las partes de la casa.
```pythonclass CasaBuilder:    def \_\_init\_\_(self):        self.casa = Casa()
    def set\_habitaciones(self, numero):        self.casa.habitaciones = numero        return self
    def set\_material(self, material):        self.casa.material = material        return self
    def set\_techo(self, techo):        self.casa.techo = techo        return self
    def build(self):        return self.casa```
\#### Paso 3: Usar el Builder
Ahora podemos construir casas de manera flexible.
```python# Crear un builderbuilder = CasaBuilder()
\# Construir una casa personalizadacasa\_personalizada = (    builder    .set\_habitaciones(4)    .set\_material("ladrillo")    .set\_techo("tejas")    .build())
print(casa\_personalizada)```
\*\*Salida:\*\*
```Casa con 4 habitaciones, hecha de ladrillo y techo tejas.```
\### Extensión del Ejemplo: Añadir un Director
Si quieres estandarizar la construcción de casas, puedes usar un \*\*Director\*\*.
```pythonclass Director:    def \_\_init\_\_(self, builder):        self.builder = builder
    def construir\_casa\_familiar(self):        return (            self.builder            .set\_habitaciones(5)            .set\_material("concreto")            .set\_techo("tejas")            .build()        )
    def construir\_cabana(self):        return (            self.builder            .set\_habitaciones(2)            .set\_material("madera")            .set\_techo("paja")            .build()        )```
\#### Usar el Director
```python# Crear un builder y un directorbuilder = CasaBuilder()director = Director(builder)
\# Construir una casa familiarcasa\_familiar = director.construir\_casa\_familiar()print(casa\_familiar)
\# Construir una cabañacabana = director.construir\_cabana()print(cabana)```
\*\*Salida:\*\*
```Casa con 5 habitaciones, hecha de concreto y techo tejas.Casa con 2 habitaciones, hecha de madera y techo paja.```
\### Ventajas del Patrón Builder
1\. \*\*Mayor legibilidad\*\*: El código es más limpio y fácil de entender que pasar múltiples parámetros a un constructor.2. \*\*Flexibilidad\*\*: Permite construir objetos complejos en diferentes configuraciones.3. \*\*Extensibilidad\*\*: Puedes agregar nuevas configuraciones al producto sin afectar al cliente.4. \*\*Separación de preocupaciones\*\*: El proceso de construcción está separado de la representación final del objeto.
\### Aplicaciones en la Vida Real
1\. \*\*Constructores de consultas SQL\*\*: Herramientas como SQLAlchemy utilizan este patrón para construir consultas paso a paso.2. \*\*Interfaces de usuario\*\*: Para construir ventanas, paneles, y componentes complejos en GUIs.3. \*\*Configuración de APIs\*\*: Bibliotecas como `requests` o `fluent interfaces` en otros lenguajes.
\### Conclusión
El \*\*Patrón Builder\*\* es ideal para escenarios donde el objeto a construir tiene múltiples configuraciones posibles o pasos de inicialización complejos. En Python, la fluidez del patrón se beneficia del uso de métodos encadenados, lo que resulta en un código elegante y legible.

Resumen

Builder Pattern: construcción paso a paso para objetos complejos

¿Qué es el builder pattern y qué resuelve?

¿Cómo separa la construcción de la representación?

La construcción se orquesta en una clase independiente llamada Builder.
La representación final queda encapsulada en la clase producto.
La interfaz de creación es paso a paso, clara y predecible.

¿Qué rol cumplen los métodos por atributo?

Cada método configura una parte: parte A, parte B, parte C.
Se pueden encadenar pasos sin exponer los detalles internos.
El método build une todos los parámetros y devuelve el objeto completo.

¿Cuándo aplicar este patrón de diseño creacional?

Cuando un objeto necesita varios pasos de configuración.
Cuando la clase se volvió compleja y requiere simplificación con un nuevo paradigma.
Cuando es clave separar el proceso de construcción de su resultado final.
Cuando se deben crear diferentes variantes del mismo objeto sin duplicar lógica.

¿Cómo implementarlo paso a paso?

La implementación se centra en mover la lógica de construcción a una clase Builder y ofrecer una interfaz clara por atributo, cerrando con build para ensamblar el objeto final.

Separar la construcción en una clase llamada Builder.
Crear métodos específicos por cada atributo del producto: parte A, parte B, parte C.
Definir el método build para unir los parámetros indicados en los pasos y construir la clase final.
Mantener la interfaz de creación paso a paso para legibilidad y mantenimiento.
Favorecer variantes del producto sin alterar su representación.

¿Has aplicado el patrón Builder en algún proyecto profesional? Comparte tu experiencia en los comentarios y qué retos resolviste con este enfoque.

    def \_\_str\_\_(self):        return f"Casa con {self.habitaciones} habitaciones, hecha de {self.material} y techo {self.techo}."```
\#### Paso 2: Crear el Builder
Define una clase `CasaBuilder` que contiene métodos para configurar las partes de la casa.
```pythonclass CasaBuilder:    def \_\_init\_\_(self):        self.casa = Casa()
    def set\_habitaciones(self, numero):        self.casa.habitaciones = numero        return self
    def set\_material(self, material):        self.casa.material = material        return self
    def set\_techo(self, techo):        self.casa.techo = techo        return self
    def build(self):        return self.casa```
\#### Paso 3: Usar el Builder
Ahora podemos construir casas de manera flexible.
```python# Crear un builderbuilder = CasaBuilder()
\# Construir una casa personalizadacasa\_personalizada = (    builder    .set\_habitaciones(4)    .set\_material("ladrillo")    .set\_techo("tejas")    .build())
print(casa\_personalizada)```
\*\*Salida:\*\*
```Casa con 4 habitaciones, hecha de ladrillo y techo tejas.```
\### Extensión del Ejemplo: Añadir un Director
Si quieres estandarizar la construcción de casas, puedes usar un \*\*Director\*\*.
```pythonclass Director:    def \_\_init\_\_(self, builder):        self.builder = builder
    def construir\_casa\_familiar(self):        return (            self.builder            .set\_habitaciones(5)            .set\_material("concreto")            .set\_techo("tejas")            .build()        )
    def construir\_cabana(self):        return (            self.builder            .set\_habitaciones(2)            .set\_material("madera")            .set\_techo("paja")            .build()        )```
\#### Usar el Director
```python# Crear un builder y un directorbuilder = CasaBuilder()director = Director(builder)
\# Construir una casa familiarcasa\_familiar = director.construir\_casa\_familiar()print(casa\_familiar)
\# Construir una cabañacabana = director.construir\_cabana()print(cabana)```
\*\*Salida:\*\*
```Casa con 5 habitaciones, hecha de concreto y techo tejas.Casa con 2 habitaciones, hecha de madera y techo paja.```
\### Ventajas del Patrón Builder
1\. \*\*Mayor legibilidad\*\*: El código es más limpio y fácil de entender que pasar múltiples parámetros a un constructor.2. \*\*Flexibilidad\*\*: Permite construir objetos complejos en diferentes configuraciones.3. \*\*Extensibilidad\*\*: Puedes agregar nuevas configuraciones al producto sin afectar al cliente.4. \*\*Separación de preocupaciones\*\*: El proceso de construcción está separado de la representación final del objeto.
\### Aplicaciones en la Vida Real
1\. \*\*Constructores de consultas SQL\*\*: Herramientas como SQLAlchemy utilizan este patrón para construir consultas paso a paso.2. \*\*Interfaces de usuario\*\*: Para construir ventanas, paneles, y componentes complejos en GUIs.3. \*\*Configuración de APIs\*\*: Bibliotecas como `requests` o `fluent interfaces` en otros lenguajes.
\### Conclusión
El \*\*Patrón Builder\*\* es ideal para escenarios donde el objeto a construir tiene múltiples configuraciones posibles o pasos de inicialización complejos. En Python, la fluidez del patrón se beneficia del uso de métodos encadenados, lo que resulta en un código elegante y legible.

Comentarios (3)3 comentarios

Jovanny Delgado

Hace 2 años

Patrón Builder en Python: Construyendo objetos paso a paso

El patrón Builder es un patrón de diseño de creación que separa la construcción de un objeto complejo de su representación, permitiendo así construir objetos de la misma familia pero con diferentes representaciones. En Python, este patrón es especialmente útil para crear objetos con múltiples atributos o configuraciones.

¿Por qué usar el patrón Builder?

Mayor legibilidad: Al separar la construcción de la representación, el código se vuelve más fácil de entender y mantener.
Flexibilidad: Permite crear diferentes representaciones de un objeto con el mismo conjunto de componentes.
Encapsulación: Oculta la complejidad de la construcción del objeto.
Paso a paso: Permite construir objetos de forma gradual, agregando componentes uno por uno.

Ejemplo práctico: Construyendo una computadora

Pythonclass Computer: def __init__(self, builder): self.cpu = builder.cpu self.ram = builder.ram self.hdd = builder.hdd

class ComputerBuilder: def __init__(self): self.cpu = None self.ram = None self.hdd = None

def set_cpu(self, cpu): self.cpu = cpu return self

def set_ram(self, ram): self.ram = ram return self

def set_hdd(self, hdd): self.hdd = hdd return self

def build(self): return Computer(self)

# Uso del builder computer_builder = ComputerBuilder() computer = computer_builder.set_cpu("Intel i9").set_ram("32GB").set_hdd("1TB").build()

Explicación del código

Clase Computer: Representa el objeto final que queremos construir.
Clase ComputerBuilder:
- Métodos set_cpu, set_ram y set_hdd: Permiten configurar los diferentes componentes de la computadora.
- Método build: Crea una instancia de la clase Computer con los componentes configurados.

Ventajas de este enfoque:

Fluidez: La sintaxis en cadena permite construir objetos de manera fluida y legible.
Flexibilidad: Puedes crear diferentes configuraciones de computadoras sin cambiar la clase Computer.
Reutilización: El builder puede ser reutilizado para crear múltiples objetos.

Otros casos de uso

Creación de objetos con muchos parámetros.
Creación de objetos complejos con múltiples pasos de configuración.
Generación de informes complejos.

Consideraciones adicionales

Director: A veces, se introduce un objeto director que coordina el proceso de construcción, especialmente cuando hay múltiples builders o pasos complejos.
Builder abstracto: Se puede definir una clase abstracta Builder para establecer una interfaz común para todos los builders.

El patrón Builder es una herramienta poderosa en Python para construir objetos complejos de forma flexible y legible. Al separar la construcción de la representación, promueve un código más limpio y mantenible.

Mario Alexander Vargas Celis

El **Patrón Builder** es un patrón de diseño creacional que permite construir objetos complejos paso a paso. Aporta una forma organizada de crear objetos configurables sin sobrecargar el constructor de la clase con demasiados parámetros, haciendo que el código sea más legible y fácil de mantener. ### Conceptos Clave del Patrón Builder 1. **Separación de la construcción y representación**: El proceso de construcción se divide en pasos que construyen partes del objeto. 2. **Facilidad de configuración**: Puedes configurar un objeto de diferentes maneras mediante el uso de constructores personalizados.3. **Director opcional**: Un director es una clase que orquesta el proceso de construcción. ### Ejemplo: Construcción de una "Casa" Imaginemos que queremos construir casas con diferentes configuraciones, como número de habitaciones, materiales, tipo de techo, etc. #### Paso 1: Crear la Clase del Producto Define la clase que será construida, en este caso, una Casa.

Franco Manca

El patrón Builder es un patrón de diseño creacional que separa la construcción de un objeto complejo de su representación final.

Características:

Permite crear diferentes representaciones de un objeto.
Proporciona una interfaz para la construcción paso a paso del objeto.
Facilita la creación de objetos con múltiples atributos.

Cuándo aplicarlo:

Cuando la creación de un objeto implica múltiples pasos.
Si la construcción es demasiado compleja o confusa.
Cuando deseas separar la construcción del objeto de su representación.

Cómo aplicarlo:

Crea una clase Builder con métodos para cada atributo del objeto.
Define un método build() que unifique los atributos y construya el objeto final.

Este patrón es útil para simplificar la creación de objetos complejos y mejorar la legibilidad del código.

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Qué es el principio de responsabilidad única

Procesador de pagos en Python con Stripe

Cómo aplicar SRP en un procesador de pagos con Stripe

Principio open-closed en Python

Clases abstractas y principio abierto-cerrado

Principio de Liskov en S.O.L.I.D.

Principio de sustitución de Liskov en Python

Principio de segregación de interfaces en SOLID

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias en SOLID

Principio de inversión de dependencias: servicio de pagos flexible

Reestructuración del proyecto

Reestructuración con módulos de Python y SOLID

Patrones de Diseño

Qué son los patrones de diseño: definición y categorías

Strategy Pattern con Python y setprocessor

Strategy Pattern para pagos en Python

Factory Pattern: centralizar creación de objetos

Patrón Factory para procesar pagos con match

Qué es el patrón Decorator

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder Pattern aplicado a un servicio de pagos

Observer Pattern en sistemas de eventos

Observer en sistemas de pagos con Python

Chain of Responsibility para validar pagos

Chain of Responsibility en servicios de pagos

Código funcional vs código mantenible en Python

Builder Pattern: construcción paso a paso

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos