Zum Inhalt
wannacode

Builder

Kurz gesagt: Builder baut ein komplexes Objekt Schritt für Schritt zusammen, mit einem Namen für jedes Feld, und prüft es in build(); in Python tun Schlüsselwortargumente und Dataclass oft dasselbe.

Problem

Neun Parameter und zwei vertauschte Wörter

Der Shop schickt eine E-Mail, wenn eine Bestellung versandt wird. Die E-Mail hat neun Felder: an wen sie geht, die Adresse für Antworten, den Betreff, den Text, eine Kopie, eine Blindkopie, einen Anhang, ob sie wichtig ist und ob das Öffnen verfolgt wird.

class Email:
    def __init__(self, to, reply_to, subject, body, cc, bcc,
                 attachment, high_priority, track_opens):
        self.to = to
        self.reply_to = reply_to
        self.subject = subject
        self.body = body
        self.cc = cc
        self.bcc = bcc
        self.attachment = attachment
        self.high_priority = high_priority
        self.track_opens = track_opens


    def send(self):
        print(f"An: {self.to}")
        if self.reply_to:
            print(f"Antwort an: {self.reply_to}")
        print(f"Betreff: {self.subject}")
        if self.attachment:
            print(f"Anhang: {self.attachment}")
        if self.high_priority:
            print("Hohe Priorität")

So wird die Bestätigung für Bestellung 1042 verschickt:

email = Email("support@shop.example", "maria@example.com", "Bestellung 1042 wurde versandt",
              "Dein Paket ist unterwegs.", None, None, "invoice-1042.pdf", True, False)
email.send()
Ausgabe
An: support@shop.example
Antwort an: maria@example.com
Betreff: Bestellung 1042 wurde versandt
Anhang: invoice-1042.pdf
Hohe Priorität

Die E-Mail ging an den Support des Shops, und Maria hat nichts bekommen. Die ersten beiden Argumente sind vertauscht. Beide sind Text, also kann die Sprache es nicht erkennen. Und welches ist am Ende true und welches false? Um das herauszufinden, zählst du Positionen im Konstruktor. Zwei None halten die Plätze von Feldern frei, die diese E-Mail nicht hat.

Python hat Schlüsselwortargumente (reply_to="…"), aber nichts zwingt dich, sie zu benutzen: Der Aufruf mit Positionen läuft ohne Fehler.

Jedes neue Feld, sagen wir die Sprache der E-Mail, ändert den Konstruktor und jede Stelle, die ihn aufruft.

Die Idee

Builder: über Namen, in Schritten, mit Prüfung

Das Objekt entsteht nicht durch einen Aufruf mit neun Positionen, sondern in Schritten, jeder mit einem Namen: .to(…), .subject(…). Die Schritte gehen an ein eigenes Objekt, den Builder. Er sammelt die Werte, und am Ende build():

  • prüft die Pflichtfelder (hier: Empfänger, Betreff und Text) und wirft eine Exception, wenn eins fehlt;
  • erzeugt ein unveränderliches Objekt: Danach kann sich die E-Mail nicht mehr ändern.

Das ist das Muster Builder. Die Rollen:

  • das Produkt: Email, unveränderlich;
  • der Builder: EmailBuilder, mit einer Methode für jedes Feld. Die Methode gibt den Builder selbst zurück, sodass sich die Aufrufe in einer Kette aneinanderreihen;
  • build(): die einzige Stelle, an der das Produkt geprüft und erzeugt wird.
In Python gibt es für das Problem der ersten Karte auch eine kürzere Antwort: Schlüsselwortargumente. Sie steht in der Karte „Ohne Builder“. Der Builder hier ist für den Fall, dass die E-Mail in Schritten an verschiedenen Stellen im Code zusammengesetzt wird.

Sieh es dir an

Die Kette und build()

@dataclass(frozen=True, kw_only=True)
class Email:
    to: str
    reply_to: str | None = None
    subject: str
    body: str
    cc: str | None = None
    bcc: str | None = None
    attachment: str | None = None
    high_priority: bool = False
    track_opens: bool = False


    def send(self):
        print(f"An: {self.to}")
        if self.reply_to:
            print(f"Antwort an: {self.reply_to}")
        print(f"Betreff: {self.subject}")
        if self.attachment:
            print(f"Anhang: {self.attachment}")
        if self.high_priority:
            print("Hohe Priorität")




class EmailBuilder:
    def __init__(self):
        self.fields = {}


    def to(self, value):
        self.fields["to"] = value
        return self


    def reply_to(self, value):
        self.fields["reply_to"] = value
        return self


    def subject(self, value):
        self.fields["subject"] = value
        return self


    def body(self, value):
        self.fields["body"] = value
        return self


    def cc(self, value):
        self.fields["cc"] = value
        return self


    def bcc(self, value):
        self.fields["bcc"] = value
        return self


    def attachment(self, value):
        self.fields["attachment"] = value
        return self


    def high_priority(self):
        self.fields["high_priority"] = True
        return self


    def track_opens(self):
        self.fields["track_opens"] = True
        return self


    def build(self):
        if "to" not in self.fields:
            raise ValueError("Empfänger fehlt")
        if "subject" not in self.fields:
            raise ValueError("Betreff fehlt")
        if "body" not in self.fields:
            raise ValueError("Text fehlt")
        return Email(**self.fields)

Ein Builder kostet Code: Jedes Feld wird sowohl in der E-Mail als auch in der Methode des Builders geschrieben. Deshalb baut man ihn nicht für jede Klasse.

@dataclass(frozen=True, kw_only=True) schreibt __init__ für dich: frozen=True verbietet Änderungen nach der Erzeugung, und kw_only=True nimmt die Felder nur über Namen. **self.fields übergibt das Dictionary als Schlüsselwortargumente.
email = (
    EmailBuilder()
    .to("maria@example.com")
    .subject("Bestellung 1042 wurde versandt")
    .body("Dein Paket ist unterwegs.")
    .attachment("invoice-1042.pdf")
    .high_priority()
    .build()
)
email.send()


draft = (
    EmailBuilder()
    .to("peter@example.com")
    .body("Dein Paket ist unterwegs.")
)
try:
    draft.build()
except ValueError as e:
    print(e)
Ausgabe
An: maria@example.com
Betreff: Bestellung 1042 wurde versandt
Anhang: invoice-1042.pdf
Hohe Priorität
Betreff fehlt

email = (
    EmailBuilder()
    .to("maria@example.com")
    .subject("Bestellung 1042 wurde versandt")
    .body("Dein Paket ist unterwegs.")
    .attachment("invoice-1042.pdf")
    .high_priority()
    .build()
)
email.send()


draft = (
    EmailBuilder()
    .to("peter@example.com")
    .body("Dein Paket ist unterwegs.")
)
try:
    draft.build()
except ValueError as e:
    print(e)
Schritt für Schritt, in Worten
  1. EmailBuilder(): ein leerer Bauplan mit neun Feldern. Die drei Pflichtfelder (to, subject, body) sind markiert.
  2. .to(…) füllt ein Feld und gibt denselben Builder zurück, also geht die Kette weiter.
  3. Jeder Aufruf hat einen Namen: Ein Wert kann nicht im falschen Feld landen, wie es bei den Positionen im Konstruktor passierte.
  4. .body(…): Alle drei Pflichtfelder sind gefüllt.
  5. Optionale Felder schreibst du nur, wenn du sie brauchst. high_priority() hat kein Argument: kein true mehr an achter Stelle.
  6. build() prüft die Pflichtfelder und stanzt eine Email aus. Ihre Felder sind frozen=True: Das Objekt ändert sich nicht mehr.
  7. Die E-Mail geht an Maria, mit der Rechnung, mit hoher Priorität.
  8. Ein neuer Builder, ein neuer leerer Bauplan. Hier hat jemand den Betreff vergessen.
  9. draft.build() stößt auf das leere Feld subject und bricht mit einer Exception ab. Eine E-Mail ohne Betreff entsteht gar nicht erst.
  10. Der Fehler sagt, was fehlt. Es wurde nichts gesendet.

Die E-Mail ohne Betreff erreicht nie die Post: build() stoppt sie schon beim Zusammenbau.

Sieh es dir an

Ohne Builder: was die Sprache bietet

Python hat das in der Sprache selbst. Die Felder mit Standardwert sind optional, und kw_only=True erlaubt nur den Aufruf über Namen. Eine Prüfung, die die Dataclass nicht von allein macht, kommt in __post_init__:
@dataclass(frozen=True, kw_only=True)
class Email:
    to: str
    reply_to: str | None = None
    subject: str
    body: str
    cc: str | None = None
    bcc: str | None = None
    attachment: str | None = None
    high_priority: bool = False
    track_opens: bool = False


    def __post_init__(self):
        if "@" not in self.to:
            raise ValueError(f"Ungültige Adresse: {self.to}")
email = Email(
    to="maria@example.com",
    subject="Bestellung 1042 wurde versandt",
    body="Dein Paket ist unterwegs.",
    attachment="invoice-1042.pdf",
    high_priority=True,
)
print(email.to, "/", email.subject, "/", email.high_priority)
Ausgabe
maria@example.com / Bestellung 1042 wurde versandt / True
Der Aufruf mit Positionen von der ersten Karte geht nicht mehr durch:
email = Email("support@shop.example", "maria@example.com", "Bestellung 1042 wurde versandt")
Fehler
TypeError: Email.__init__() takes 1 positional argument but 4 were given

Wann sich ein Builder trotzdem lohnt:

  • die E-Mail wird in Schritten an verschiedenen Stellen des Codes zusammengesetzt: Der Anhang kommt nur dazu, wenn es eine Rechnung gibt, die Kopie nur bei Firmen;
  • es gibt eine Prüfung über mehrere Felder: Zum Beispiel darf die Blindkopie nicht die Adresse des Empfängers sein;
  • es gibt viele Felder, die meisten optional, und der Zusammenbau muss von einer Stelle zur anderen weitergereicht werden, bevor er fertig ist.

Probier es aus

Sag die Ausgabe voraus

Ein Builder, zwei Aufrufe von build(). Was gibt das Programm aus?

builder = (
    EmailBuilder()
    .to("maria@example.com")
    .subject("Bestellung 1042 wurde versandt")
    .body("Dein Paket ist unterwegs.")
)
first = builder.build()
builder.high_priority()
second = builder.build()
print(first.high_priority, second.high_priority)
Antwort

Probier es aus

Finde den Fehler

Der Shop schickt die E-Mails für versandte Bestellungen in einer Schleife. Nur die erste Bestellung hat eine Rechnung:

orders = [
    ("maria@example.com", 1042, "invoice-1042.pdf"),
    ("peter@example.com", 1043, None),
]
builder = EmailBuilder().reply_to("support@shop.example")
for email, order_id, invoice in orders:
    builder.to(email).subject(f"Bestellung {order_id} wurde versandt")
    builder.body("Dein Paket ist unterwegs.")
    if invoice:
        builder.attachment(invoice)
    builder.build().send()
Ausgabe
An: maria@example.com
Antwort an: support@shop.example
Betreff: Bestellung 1042 wurde versandt
Anhang: invoice-1042.pdf
An: peter@example.com
Antwort an: support@shop.example
Betreff: Bestellung 1043 wurde versandt
Anhang: invoice-1042.pdf

Peter hat die Rechnung von Maria bekommen. In welcher Zeile steckt der Fehler?

Wähle die Zeile mit dem Fehler.

Die Idee

Wann du ihn nicht brauchst

Builder verdoppelt den Code der Klasse. Er lohnt sich nicht, wenn:

  • es zwei oder drei Felder gibt und alle Pflicht sind: Ein einfacher Konstruktor ist klarer;
  • Schlüsselwortargumente und eine Dataclass dasselbe ohne zweite Klasse tun;
  • das Objekt nichts zu prüfen hat und nicht in Schritten zusammengesetzt wird.

Er lohnt sich, wenn es viele Felder gibt und die meisten optional sind, wenn es eine Prüfung über mehrere gibt oder wenn das Objekt in Schritten an verschiedenen Stellen des Codes zusammengesetzt wird.

Übung

Ein Paket für den Kurier

Löse die Aufgabe in deinem Editor.

Ein Builder für ein Paket. Der Kurier will ein Paket mit Empfänger, Telefon, Adresse und Gewicht (Pflicht) und optional: zerbrechlich und Nachnahme. Schreibe Shipment und einen Builder dafür. build() prüft, dass die Pflichtfelder gesetzt sind und dass das Gewicht über 0 und bis 30 kg liegt. Erzeuge ein Paket für Maria (2,5 kg, zerbrechlich, Nachnahme 42,90 €), gib es aus und probiere ein Paket mit 45 kg:

Ausgabe
Paket für Maria, 0888 123 456
Adresse: Gartenstraße 5, Hamburg
Gewicht: 2.5 kg, zerbrechlich
Nachnahme: 42.90 €
Das Gewicht muss über 0 und bis 30 kg liegen

Weitere Aufgaben

  • Die Schleife reparieren. Repariere das Programm aus „Finde den Fehler“ so, dass jede E-Mail nur ihre eigene Rechnung trägt. Die Antwortadresse muss für alle E-Mails bleiben.
  • Eine Kopie mit einer Änderung. Füge eine Methode hinzu, die aus einer fertigen E-Mail einen Builder mit denselben Werten macht (in Java heißt sie oft toBuilder()). Schicke dieselbe E-Mail an einen anderen Empfänger.
  • Der Weg der Sprache. Schreibe Shipment wie in der Karte „Ohne Builder“ und vergleiche die beiden Versionen. Welche ist kürzer, und was verlierst du?

Test

Teste dich

1. Email("support@…", "maria@…", …) läuft ohne Fehler, und die E-Mail geht woandershin. Warum hat Python nicht geholfen?
2. Was macht build()?
3. Der Builder wird vor der Schleife erzeugt und für jede E-Mail benutzt. Die zweite E-Mail hat den Anhang der ersten bekommen. Warum?
4. Wann lohnt sich Builder trotzdem?
5. Was löst in Python das Problem mit den neun Positionsargumenten?

Erstellt von Ivo Gergov im Rahmen der Kampagne von Evo Tech für zugängliche Programmierausbildung ·