🎉 Hooray! After 3 years of work, I've finally released the ebook on design patterns! Check it out »

Builder in Python

Builder is a creational design pattern, which allows constructing complex objects step by step.

Unlike other creational patterns, Builder doesn’t require products to have a common interface. That makes it possible to produce different products using the same construction process.

Learn more about Builder

Usage of the pattern in Python



Usage examples: The Builder pattern is a well-known pattern in Python world. It’s especially useful when you need to create an object with lots of possible configuration options.

Identification: The Builder pattern can be recognized in class, which has a single creational method and several methods to configure the resulting object. Builder methods often support chaining (for example, someBuilder->setValueA(1)->setValueB(2)->create()).

Conceptual Example

This example illustrates the structure of the Builder design pattern. It focuses on answering these questions:

  • What classes does it consists of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

main.py: Conceptual Example

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

class Builder(ABC):
    The Builder interface specifies methods for creating the different parts
    of the Product objects.

    def product(self) -> None:

    def produce_part_a(self) -> None:

    def produce_part_b(self) -> None:

    def produce_part_c(self) -> None:

class ConcreteBuilder1(Builder):
    The Concrete Builder classes follow the Builder interface and provide
    specific implementations of the building steps. Your program may have
    several variations of Builders, implemented differently.

    def __init__(self) -> None:
        A fresh builder instance should contain a blank product object, which
        is used in further assembly.

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

    def product(self) -> Product1:
        Concrete Builders are supposed to provide their own methods for
        retrieving results. That's because various types of builders may
        create entirely different products that don't follow the same
        interface. Therefore, such methods cannot be declared in the base
        Builder interface (at least in a statically typed programming
        Usually, after returning the end result to the client, a builder
        instance is expected to be ready to start producing another product.
        That's why it's a usual practice to call the reset method at the end
        of the `getProduct` method body. However, this behavior is not
        mandatory, and you can make your builders wait for an explicit reset
        call from the client code before disposing of the previous result.
        product = self._product
        return product

    def produce_part_a(self) -> None:

    def produce_part_b(self) -> None:

    def produce_part_c(self) -> None:

class Product1():
    It makes sense to use the Builder pattern only when your products are
    quite complex and require extensive configuration.
    Unlike in other creational patterns, different concrete builders can
    produce unrelated products. In other words, results of various builders
    may not always follow the same interface.

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

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

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

class Director:
    The Director is only responsible for executing the building steps in a
    particular sequence. It is helpful when producing products according to a
    specific order or configuration. Strictly speaking, the Director class is
    optional, since the client can control builders directly.

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

    def builder(self) -> Builder:
        return self._builder

    def builder(self, builder: Builder) -> None:
        The Director works with any builder instance that the client code
        passes to it. This way, the client code may alter the final type of
        the newly assembled product.
        self._builder = builder

    The Director can construct several product variations using the same
    building steps.

    def build_minimal_viable_product(self) -> None:

    def build_full_featured_product(self) -> None:

if __name__ == "__main__":
    The client code creates a builder object, passes it to the director and
    then initiates the construction process. The end result is retrieved from
    the builder object.

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

    print("Standard basic product: ")


    print("Standard full featured product: ")


    # Remember, the Builder pattern can be used without a Director class.
    print("Custom product: ")

Output.txt: Output

Standard basic product: 
Product parts: PartA1

Standard full featured product: 
Product parts: PartA1, PartB1, PartC1

Custom product: 
Product parts: PartA1, PartB1

Builder in Other Languages

Builder in Java Builder in C# Builder in PHP Builder in TypeScript