Skip to content

Builder Pattern

Category: Creational Pattern

Overview

Separate the construction of a complex object from its representation, allowing the same construction process to create different representations. This pattern provides a step-by-step approach to constructing objects, particularly useful when objects require many configuration parameters or complex initialization.

Usage Guidelines

Use when:

  • Object creation involves many steps or configuration options
  • Same construction process should create different representations
  • Many optional parameters would lead to multiple constructors
  • Building immutable objects step by step before finalization

Avoid when:

  • Object has few parameters and simple construction
  • Object always created the same way
  • Builder adds unacceptable performance overhead
  • Python dataclasses or named tuples work well

Implementation

from __future__ import annotations

class Computer:
    """Represents a computer with various components.

    This is the product class that the builder constructs.
    """

    def __init__(self) -> None:
        """Initialize an empty computer."""
        self.cpu: str | None = None
        self.ram: int | None = None
        self.storage: str | None = None
        self.gpu: str | None = None
        self.os: str | None = None
        self.peripherals: list[str] = []

    def get_specifications(self) -> str:
        """Get the computer specifications as a formatted string.

        Returns:
            A string representation of the computer specifications.
        """
        specs = []
        if self.cpu:
            specs.append(f"CPU: {self.cpu}")
        if self.ram:
            specs.append(f"RAM: {self.ram}GB")
        if self.storage:
            specs.append(f"Storage: {self.storage}")
        if self.gpu:
            specs.append(f"GPU: {self.gpu}")
        if self.os:
            specs.append(f"OS: {self.os}")
        if self.peripherals:
            specs.append(f"Peripherals: {', '.join(self.peripherals)}")
        return "\n".join(specs) if specs else "No specifications set"

class ComputerBuilder:
    """Builder for constructing Computer objects.

    This builder uses method chaining (fluent interface) to set component properties.
    """

    def __init__(self) -> None:
        """Initialize the builder with a new Computer instance."""
        self._computer = Computer()

    def set_cpu(self, cpu: str) -> ComputerBuilder:
        """Set the CPU.

        Args:
            cpu: The CPU model.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.cpu = cpu
        return self

    def set_ram(self, ram: int) -> ComputerBuilder:
        """Set the RAM amount in GB.

        Args:
            ram: The RAM size in gigabytes.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.ram = ram
        return self

    def set_storage(self, storage: str) -> ComputerBuilder:
        """Set the storage configuration.

        Args:
            storage: The storage description.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.storage = storage
        return self

    def set_gpu(self, gpu: str) -> ComputerBuilder:
        """Set the GPU.

        Args:
            gpu: The GPU model.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.gpu = gpu
        return self

    def set_os(self, os: str) -> ComputerBuilder:
        """Set the operating system.

        Args:
            os: The operating system name.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.os = os
        return self

    def add_peripheral(self, peripheral: str) -> ComputerBuilder:
        """Add a peripheral device.

        Args:
            peripheral: The peripheral name.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.peripherals.append(peripheral)
        return self

    def build(self) -> Computer:
        """Build and return the configured Computer instance.

        Returns:
            The fully constructed Computer instance.
        """
        return self._computer

    def reset(self) -> ComputerBuilder:
        """Reset the builder to start building a new computer.

        Returns:
            The builder instance with a new Computer.
        """
        self._computer = Computer()
        return self

Usage

# Building a custom computer
builder = ComputerBuilder()
computer = (builder
            .set_cpu("Intel i9")
            .set_ram(32)
            .set_storage("1TB SSD")
            .set_gpu("NVIDIA RTX 4090")
            .set_os("Windows 11")
            .add_peripheral("Mechanical Keyboard")
            .add_peripheral("Gaming Mouse")
            .build())

print(computer.get_specifications())
# Output:
# CPU: Intel i9
# RAM: 32GB
# Storage: 1TB SSD
# GPU: NVIDIA RTX 4090
# OS: Windows 11
# Peripherals: Mechanical Keyboard, Gaming Mouse

Trade-offs

Benefits:

  1. Readable code through fluent interface that is self-documenting
  2. Step-by-step construction of complex objects incrementally
  3. Same builder can create different product variants
  4. Can construct immutable objects piece by piece

Drawbacks:

  1. Adds extra classes and code, increasing complexity
  2. Builder methods may duplicate product setters
  3. Creates intermediate objects during construction
  4. Product may be in invalid state during construction

Real-World Examples

  • SQL query builders constructing complex queries
  • HTTP request builders with headers, body, parameters
  • Document builders creating documents with sections
  • Test data builders with various configurations
  • Abstract Factory
  • Composite
  • Prototype
  • Singleton
  • Fluent Interface

API Reference

design_patterns.creational.builder

Builder Pattern Module

The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create different representations. It is particularly useful when an object requires many configuration parameters or when the construction process involves multiple steps.

Example

Building a computer with various components:

builder = ComputerBuilder()
computer = (builder
            .set_cpu("Intel i9")
            .set_ram(32)
            .set_storage("1TB SSD")
            .set_gpu("NVIDIA RTX 4090")
            .build())

print(computer.get_specifications())

Computer

Represents a computer with various components.

This is the product class that the builder constructs.

Source code in src/design_patterns/creational/builder.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class Computer:
    """Represents a computer with various components.

    This is the product class that the builder constructs.
    """

    def __init__(self) -> None:
        """Initialize an empty computer."""
        self.cpu: str | None = None
        self.ram: int | None = None
        self.storage: str | None = None
        self.gpu: str | None = None
        self.os: str | None = None
        self.peripherals: list[str] = []

    def get_specifications(self) -> str:
        """Get the computer specifications as a formatted string.

        Returns:
            A string representation of the computer specifications.
        """
        specs = []
        if self.cpu:
            specs.append(f"CPU: {self.cpu}")
        if self.ram:
            specs.append(f"RAM: {self.ram}GB")
        if self.storage:
            specs.append(f"Storage: {self.storage}")
        if self.gpu:
            specs.append(f"GPU: {self.gpu}")
        if self.os:
            specs.append(f"OS: {self.os}")
        if self.peripherals:
            specs.append(f"Peripherals: {', '.join(self.peripherals)}")
        return "\n".join(specs) if specs else "No specifications set"

__init__()

Initialize an empty computer.

Source code in src/design_patterns/creational/builder.py 
35
36
37
38
39
40
41
42
def __init__(self) -> None:
    """Initialize an empty computer."""
    self.cpu: str | None = None
    self.ram: int | None = None
    self.storage: str | None = None
    self.gpu: str | None = None
    self.os: str | None = None
    self.peripherals: list[str] = []

get_specifications()

Get the computer specifications as a formatted string.

Returns:

Type Description
str

A string representation of the computer specifications.
Source code in src/design_patterns/creational/builder.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def get_specifications(self) -> str:
    """Get the computer specifications as a formatted string.

    Returns:
        A string representation of the computer specifications.
    """
    specs = []
    if self.cpu:
        specs.append(f"CPU: {self.cpu}")
    if self.ram:
        specs.append(f"RAM: {self.ram}GB")
    if self.storage:
        specs.append(f"Storage: {self.storage}")
    if self.gpu:
        specs.append(f"GPU: {self.gpu}")
    if self.os:
        specs.append(f"OS: {self.os}")
    if self.peripherals:
        specs.append(f"Peripherals: {', '.join(self.peripherals)}")
    return "\n".join(specs) if specs else "No specifications set"

ComputerBuilder

Builder for constructing Computer objects.

This builder uses method chaining (fluent interface) to set component properties.

Source code in src/design_patterns/creational/builder.py 
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
class ComputerBuilder:
    """Builder for constructing Computer objects.

    This builder uses method chaining (fluent interface) to set component properties.
    """

    def __init__(self) -> None:
        """Initialize the builder with a new Computer instance."""
        self._computer = Computer()

    def set_cpu(self, cpu: str) -> ComputerBuilder:
        """Set the CPU.

        Args:
            cpu: The CPU model.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.cpu = cpu
        return self

    def set_ram(self, ram: int) -> ComputerBuilder:
        """Set the RAM amount in GB.

        Args:
            ram: The RAM size in gigabytes.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.ram = ram
        return self

    def set_storage(self, storage: str) -> ComputerBuilder:
        """Set the storage configuration.

        Args:
            storage: The storage description.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.storage = storage
        return self

    def set_gpu(self, gpu: str) -> ComputerBuilder:
        """Set the GPU.

        Args:
            gpu: The GPU model.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.gpu = gpu
        return self

    def set_os(self, os: str) -> ComputerBuilder:
        """Set the operating system.

        Args:
            os: The operating system name.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.os = os
        return self

    def add_peripheral(self, peripheral: str) -> ComputerBuilder:
        """Add a peripheral device.

        Args:
            peripheral: The peripheral name.

        Returns:
            The builder instance for method chaining.
        """
        self._computer.peripherals.append(peripheral)
        return self

    def build(self) -> Computer:
        """Build and return the configured Computer instance.

        Returns:
            The fully constructed Computer instance.
        """
        return self._computer

    def reset(self) -> ComputerBuilder:
        """Reset the builder to start building a new computer.

        Returns:
            The builder instance with a new Computer.
        """
        self._computer = Computer()
        return self

__init__()

Initialize the builder with a new Computer instance.

Source code in src/design_patterns/creational/builder.py 
72
73
74
def __init__(self) -> None:
    """Initialize the builder with a new Computer instance."""
    self._computer = Computer()

add_peripheral(peripheral)

Add a peripheral device.

Parameters:

Name Type Description Default
peripheral str

The peripheral name.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
136
137
138
139
140
141
142
143
144
145
146
def add_peripheral(self, peripheral: str) -> ComputerBuilder:
    """Add a peripheral device.

    Args:
        peripheral: The peripheral name.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.peripherals.append(peripheral)
    return self

build()

Build and return the configured Computer instance.

Returns:

Type Description
Computer

The fully constructed Computer instance.
Source code in src/design_patterns/creational/builder.py 
148
149
150
151
152
153
154
def build(self) -> Computer:
    """Build and return the configured Computer instance.

    Returns:
        The fully constructed Computer instance.
    """
    return self._computer

reset()

Reset the builder to start building a new computer.

Returns:

Type Description
ComputerBuilder

The builder instance with a new Computer.
Source code in src/design_patterns/creational/builder.py 
156
157
158
159
160
161
162
163
def reset(self) -> ComputerBuilder:
    """Reset the builder to start building a new computer.

    Returns:
        The builder instance with a new Computer.
    """
    self._computer = Computer()
    return self

set_cpu(cpu)

Set the CPU.

Parameters:

Name Type Description Default
cpu str

The CPU model.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
76
77
78
79
80
81
82
83
84
85
86
def set_cpu(self, cpu: str) -> ComputerBuilder:
    """Set the CPU.

    Args:
        cpu: The CPU model.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.cpu = cpu
    return self

set_gpu(gpu)

Set the GPU.

Parameters:

Name Type Description Default
gpu str

The GPU model.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
112
113
114
115
116
117
118
119
120
121
122
def set_gpu(self, gpu: str) -> ComputerBuilder:
    """Set the GPU.

    Args:
        gpu: The GPU model.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.gpu = gpu
    return self

set_os(os)

Set the operating system.

Parameters:

Name Type Description Default
os str

The operating system name.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
124
125
126
127
128
129
130
131
132
133
134
def set_os(self, os: str) -> ComputerBuilder:
    """Set the operating system.

    Args:
        os: The operating system name.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.os = os
    return self

set_ram(ram)

Set the RAM amount in GB.

Parameters:

Name Type Description Default
ram int

The RAM size in gigabytes.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
88
89
90
91
92
93
94
95
96
97
98
def set_ram(self, ram: int) -> ComputerBuilder:
    """Set the RAM amount in GB.

    Args:
        ram: The RAM size in gigabytes.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.ram = ram
    return self

set_storage(storage)

Set the storage configuration.

Parameters:

Name Type Description Default
storage str

The storage description.

 required

Returns:

Type Description
ComputerBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
100
101
102
103
104
105
106
107
108
109
110
def set_storage(self, storage: str) -> ComputerBuilder:
    """Set the storage configuration.

    Args:
        storage: The storage description.

    Returns:
        The builder instance for method chaining.
    """
    self._computer.storage = storage
    return self

House

Represents a house with various features.

This demonstrates an alternative product for the builder pattern.

Source code in src/design_patterns/creational/builder.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
class House:
    """Represents a house with various features.

    This demonstrates an alternative product for the builder pattern.
    """

    def __init__(self) -> None:
        """Initialize an empty house."""
        self.foundation: str | None = None
        self.walls: str | None = None
        self.roof: str | None = None
        self.windows: int = 0
        self.doors: int = 0
        self.garage: bool = False
        self.garden: bool = False

    def describe(self) -> str:
        """Get a description of the house.

        Returns:
            A string describing the house features.
        """
        features = []
        if self.foundation:
            features.append(f"Foundation: {self.foundation}")
        if self.walls:
            features.append(f"Walls: {self.walls}")
        if self.roof:
            features.append(f"Roof: {self.roof}")
        features.append(f"Windows: {self.windows}")
        features.append(f"Doors: {self.doors}")
        if self.garage:
            features.append("Has garage")
        if self.garden:
            features.append("Has garden")
        return ", ".join(features) if features else "Empty house"

__init__()

Initialize an empty house.

Source code in src/design_patterns/creational/builder.py 
172
173
174
175
176
177
178
179
180
def __init__(self) -> None:
    """Initialize an empty house."""
    self.foundation: str | None = None
    self.walls: str | None = None
    self.roof: str | None = None
    self.windows: int = 0
    self.doors: int = 0
    self.garage: bool = False
    self.garden: bool = False

describe()

Get a description of the house.

Returns:

Type Description
str

A string describing the house features.
Source code in src/design_patterns/creational/builder.py 
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
def describe(self) -> str:
    """Get a description of the house.

    Returns:
        A string describing the house features.
    """
    features = []
    if self.foundation:
        features.append(f"Foundation: {self.foundation}")
    if self.walls:
        features.append(f"Walls: {self.walls}")
    if self.roof:
        features.append(f"Roof: {self.roof}")
    features.append(f"Windows: {self.windows}")
    features.append(f"Doors: {self.doors}")
    if self.garage:
        features.append("Has garage")
    if self.garden:
        features.append("Has garden")
    return ", ".join(features) if features else "Empty house"

HouseBuilder

Builder for constructing House objects.

This demonstrates director methods that encapsulate common build configurations.

Source code in src/design_patterns/creational/builder.py 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
class HouseBuilder:
    """Builder for constructing House objects.

    This demonstrates director methods that encapsulate common build configurations.
    """

    def __init__(self) -> None:
        """Initialize the builder with a new House instance."""
        self._house = House()

    def set_foundation(self, foundation: str) -> HouseBuilder:
        """Set the foundation type.

        Args:
            foundation: The foundation type.

        Returns:
            The builder instance for method chaining.
        """
        self._house.foundation = foundation
        return self

    def set_walls(self, walls: str) -> HouseBuilder:
        """Set the wall material.

        Args:
            walls: The wall material.

        Returns:
            The builder instance for method chaining.
        """
        self._house.walls = walls
        return self

    def set_roof(self, roof: str) -> HouseBuilder:
        """Set the roof type.

        Args:
            roof: The roof type.

        Returns:
            The builder instance for method chaining.
        """
        self._house.roof = roof
        return self

    def set_windows(self, count: int) -> HouseBuilder:
        """Set the number of windows.

        Args:
            count: Number of windows.

        Returns:
            The builder instance for method chaining.
        """
        self._house.windows = count
        return self

    def set_doors(self, count: int) -> HouseBuilder:
        """Set the number of doors.

        Args:
            count: Number of doors.

        Returns:
            The builder instance for method chaining.
        """
        self._house.doors = count
        return self

    def add_garage(self) -> HouseBuilder:
        """Add a garage to the house.

        Returns:
            The builder instance for method chaining.
        """
        self._house.garage = True
        return self

    def add_garden(self) -> HouseBuilder:
        """Add a garden to the house.

        Returns:
            The builder instance for method chaining.
        """
        self._house.garden = True
        return self

    def build(self) -> House:
        """Build and return the configured House instance.

        Returns:
            The fully constructed House instance.
        """
        return self._house

    def build_simple_house(self) -> House:
        """Build a simple house with basic features.

        This is a director method that encapsulates a common configuration.

        Returns:
            A simple house.
        """
        return (self
                .set_foundation("Concrete slab")
                .set_walls("Brick")
                .set_roof("Asphalt shingles")
                .set_windows(4)
                .set_doors(1)
                .build())

    def build_luxury_house(self) -> House:
        """Build a luxury house with premium features.

        This is a director method that encapsulates a premium configuration.

        Returns:
            A luxury house.
        """
        return (self
                .set_foundation("Deep foundation")
                .set_walls("Stone")
                .set_roof("Tile")
                .set_windows(12)
                .set_doors(3)
                .add_garage()
                .add_garden()
                .build())

__init__()

Initialize the builder with a new House instance.

Source code in src/design_patterns/creational/builder.py 
210
211
212
def __init__(self) -> None:
    """Initialize the builder with a new House instance."""
    self._house = House()

add_garage()

Add a garage to the house.

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
274
275
276
277
278
279
280
281
def add_garage(self) -> HouseBuilder:
    """Add a garage to the house.

    Returns:
        The builder instance for method chaining.
    """
    self._house.garage = True
    return self

add_garden()

Add a garden to the house.

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
283
284
285
286
287
288
289
290
def add_garden(self) -> HouseBuilder:
    """Add a garden to the house.

    Returns:
        The builder instance for method chaining.
    """
    self._house.garden = True
    return self

build()

Build and return the configured House instance.

Returns:

Type Description
House

The fully constructed House instance.
Source code in src/design_patterns/creational/builder.py 
292
293
294
295
296
297
298
def build(self) -> House:
    """Build and return the configured House instance.

    Returns:
        The fully constructed House instance.
    """
    return self._house

build_luxury_house()

Build a luxury house with premium features.

This is a director method that encapsulates a premium configuration.

Returns:

Type Description
House

A luxury house.
Source code in src/design_patterns/creational/builder.py 
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
def build_luxury_house(self) -> House:
    """Build a luxury house with premium features.

    This is a director method that encapsulates a premium configuration.

    Returns:
        A luxury house.
    """
    return (self
            .set_foundation("Deep foundation")
            .set_walls("Stone")
            .set_roof("Tile")
            .set_windows(12)
            .set_doors(3)
            .add_garage()
            .add_garden()
            .build())

build_simple_house()

Build a simple house with basic features.

This is a director method that encapsulates a common configuration.

Returns:

Type Description
House

A simple house.
Source code in src/design_patterns/creational/builder.py 
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
def build_simple_house(self) -> House:
    """Build a simple house with basic features.

    This is a director method that encapsulates a common configuration.

    Returns:
        A simple house.
    """
    return (self
            .set_foundation("Concrete slab")
            .set_walls("Brick")
            .set_roof("Asphalt shingles")
            .set_windows(4)
            .set_doors(1)
            .build())

set_doors(count)

Set the number of doors.

Parameters:

Name Type Description Default
count int

Number of doors.

 required

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
262
263
264
265
266
267
268
269
270
271
272
def set_doors(self, count: int) -> HouseBuilder:
    """Set the number of doors.

    Args:
        count: Number of doors.

    Returns:
        The builder instance for method chaining.
    """
    self._house.doors = count
    return self

set_foundation(foundation)

Set the foundation type.

Parameters:

Name Type Description Default
foundation str

The foundation type.

 required

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
214
215
216
217
218
219
220
221
222
223
224
def set_foundation(self, foundation: str) -> HouseBuilder:
    """Set the foundation type.

    Args:
        foundation: The foundation type.

    Returns:
        The builder instance for method chaining.
    """
    self._house.foundation = foundation
    return self

set_roof(roof)

Set the roof type.

Parameters:

Name Type Description Default
roof str

The roof type.

 required

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
238
239
240
241
242
243
244
245
246
247
248
def set_roof(self, roof: str) -> HouseBuilder:
    """Set the roof type.

    Args:
        roof: The roof type.

    Returns:
        The builder instance for method chaining.
    """
    self._house.roof = roof
    return self

set_walls(walls)

Set the wall material.

Parameters:

Name Type Description Default
walls str

The wall material.

 required

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
226
227
228
229
230
231
232
233
234
235
236
def set_walls(self, walls: str) -> HouseBuilder:
    """Set the wall material.

    Args:
        walls: The wall material.

    Returns:
        The builder instance for method chaining.
    """
    self._house.walls = walls
    return self

set_windows(count)

Set the number of windows.

Parameters:

Name Type Description Default
count int

Number of windows.

 required

Returns:

Type Description
HouseBuilder

The builder instance for method chaining.
Source code in src/design_patterns/creational/builder.py 
250
251
252
253
254
255
256
257
258
259
260
def set_windows(self, count: int) -> HouseBuilder:
    """Set the number of windows.

    Args:
        count: Number of windows.

    Returns:
        The builder instance for method chaining.
    """
    self._house.windows = count
    return self