Entwurfsmuster

Kurz gesagt: Ein Entwurfsmuster ist eine bewährte Lösung für ein Problem, das in vielen Programmen wiederkehrt, zum Beispiel Strategy, Observer, Factory Method, Singleton und Adapter.

Problem

Die Funktion, die mit jeder Aktion wächst

Der Preis im Shop hängt von der Aktion ab:

def final_price(price, promo):
    if promo == "student":
        return price * 0.9
    elif promo == "black friday":
        return max(price - 20, 0)
    elif promo == "stammkunde":
        return price * 0.95
    return price

print(f"{final_price(120, 'student'):.2f} €")
print(f"{final_price(120, 'black friday'):.2f} €")
print(f"{final_price(120, 'keine'):.2f} €")

Ausgabe

108.00 €
100.00 €
120.00 €

Es funktioniert. Aber das Marketing denkt sich jeden Monat eine neue Aktion aus. Jede bedeutet ein neues elif in dieser Funktion, und oft in zwei weiteren: in der für die Rechnung und in der für die Bestätigungs-E-Mail. Die Funktion kennt alle Aktionen auf einmal, und jede Änderung fasst sie an. Dieses Problem ist so häufig, dass seine Lösung einen Namen hat.

Die Idee

Entwurfsmuster

Ein Entwurfsmuster (englisch design pattern) ist eine bewährte Lösung für ein Problem, das in vielen Programmen wiederkehrt. Es ist keine Bibliothek und kein Code zum Kopieren. Es ist eine Art, die Klassen und Funktionen anzuordnen, die schon durch Tausende Projekte gegangen ist.

Die Muster teilen sich in drei Gruppen:

• Erzeugungsmuster: wie Objekte entstehen. Zum Beispiel Singleton (nur ein Objekt der Klasse) und Factory Method (welche Klasse erzeugt wird, entscheidet jemand anderes).
• Strukturmuster: wie Klassen und Objekte zu größeren zusammengesetzt werden. Zum Beispiel Adapter (verbindet unverträgliche Interfaces) und Composite (ein Baum aus Teilen, mit dem man wie mit einem Ganzen arbeitet).
• Verhaltensmuster: wie Objekte die Arbeit aufteilen und miteinander reden. Zum Beispiel Strategy (eine austauschbare Regel) und Observer (Abonnenten für ein Ereignis).

Warum es sich lohnt, sie zu kennen:

• du erfindest keine Lösung neu, die andere schon erprobt haben;
• der Code ändert sich mit weniger Risiko, weil der Teil, der sich ändert, abgetrennt ist;
• die Namen sind eine gemeinsame Sprache. „Setz hier einen Adapter ein“ sagt einer Kollegin eine ganze Struktur in einem Wort.

Genauer, für Neugierige

Der klassische Katalog ist das Buch „Design Patterns“ von 1994, geschrieben von vier Autoren, die man die „Viererbande“ nennt (Gang of Four, GoF). Es enthält 23 Muster, geschrieben für Sprachen wie C++ und Java. Hier sind die fünf, denen du am häufigsten begegnest. In Python werden einige kürzer, weil man eine Funktion als Wert übergeben kann: Wo Java ein Interface und eine Klasse braucht, reicht hier eine Funktion. Ein Muster ist kein Ziel: Wenn ein einziges if die Arbeit erledigt, brauchst du kein Muster.

Sieh es dir an

Strategy: eine austauschbare Regel

Der Rabatt wird eine Funktion, die die Kasse in einem Feld hält. Die Kasse weiß nicht, welche Aktion es ist, sie ruft nur die Funktion auf:

class Checkout:
    def __init__(self, discount):
        self.discount = discount

    def total(self, price):
        return max(self.discount(price), 0)

Jeder Rabatt ist ein Lambda:

checkout = Checkout(lambda price: price)
print(f"Ohne Rabatt: {checkout.total(120):.2f} €")

checkout.discount = lambda price: price * 0.9
print(f"Student: {checkout.total(120):.2f} €")

checkout.discount = lambda price: price - 20
print(f"Black Friday: {checkout.total(120):.2f} €")

Ausgabe

Ohne Rabatt: 120.00 €
Student: 108.00 €
Black Friday: 100.00 €

Eine neue Aktion ist ein neues Lambda. Checkout ändert sich nicht. Die Regel lässt sich auch wechseln, während das Programm läuft: Du speicherst eine neue Funktion in checkout.discount.Das ist Strategy: eine Familie von Regeln, jede mit denselben Parametern und demselben Ergebnis, sodass sie austauschbar sind. Der key, den du an sorted übergibst, ist auch eine Strategie: sorted weiß, wie man sortiert, und du sagst, wonach.

Genauer, für Neugierige

In den Büchern heißt die Klasse, die die Strategie benutzt, „Kontext“ (hier Checkout). Hat die Strategie eigene Felder, kann sie eine Klasse sein. Checkout ruft self.discount(price) auf, also muss sich das Objekt wie eine Funktion aufrufen lassen: Das gibt ihm die Methode __call__:

class PercentDiscount:
    def __init__(self, percent):
        self.percent = percent

    def __call__(self, price):
        return price * (1 - self.percent / 100)

checkout = Checkout(PercentDiscount(10))
print(f"Student: {checkout.total(120):.2f} €")

Ausgabe

Student: 108.00 €

Eine Klasse ist die bessere Wahl, wenn die Strategie eigene Felder hat oder lang ist. Ein Lambda, wenn sie eine Zeile ist.

Sieh es dir an

Observer: Abonnenten für ein Ereignis

Wenn sich der Bestand eines Produkts ändert, muss die Website die neue Anzahl zeigen, und das Lager muss nachbestellen, wenn nur noch wenige Stück da sind. Morgen kommt vielleicht noch eine E-Mail an die Kunden dazu. Das Produkt soll von keinem von ihnen wissen.

class Product:
    def __init__(self, name, quantity):
        self.name = name
        self.quantity = quantity
        self.listeners = []

    def subscribe(self, listener):
        self.listeners.append(listener)

    def set_quantity(self, quantity):
        if quantity == self.quantity:
            return
        self.quantity = quantity
        for listener in self.listeners:
            listener(self.name, quantity)

phone = Product("Telefon", 0)
phone.subscribe(lambda name, qty: print(f"Website: {name}, Bestand {qty} Stk."))


def store(name, qty):
    if qty < 3:
        print(f"Lager: Nachbestellung {name}")


phone.subscribe(store)

phone.set_quantity(10)
phone.set_quantity(2)

Ausgabe

Website: Telefon, Bestand 10 Stk.
Website: Telefon, Bestand 2 Stk.
Lager: Nachbestellung Telefon

• Wer Bescheid wissen will, abonniert mit subscribe und übergibt eine Funktion.
• Bei einer Änderung geht das Produkt die Liste durch und ruft jede Funktion mit dem Namen und der Anzahl auf. Wer die Abonnenten sind und was sie tun, geht es nichts an.
• Hat sich die Anzahl nicht geändert, wird niemand gestört.
• Ein Lambda in Python ist nur ein einziger Ausdruck, und if ist kein Ausdruck. Darum ist das Lager eine normale Funktion mit def, und subscribe(store) übergibt die Funktion selbst, ohne Klammern.

phone = Product("Telefon", 0)
phone.subscribe(lambda name, qty: print(f"Website: {name}, Bestand {qty} Stk."))


def store(name, qty):
    if qty < 3:
        print(f"Lager: Nachbestellung {name}")


phone.subscribe(store)

phone.set_quantity(10)
phone.set_quantity(2)

Schritt für Schritt, in Worten

1. Telefon mit Bestand 0 und einer leeren Liste listeners.
2. Die Website abonniert: das Lambda kommt in die Liste.
3. Das Lager auch, mit der Funktion store. Das Produkt weiß nicht, wer sie sind, nur dass es sie mit einem Namen und einer Anzahl aufrufen kann.
4. Der Bestand ändert sich auf 10. Das Produkt geht die Liste durch und ruft jeden Abonnenten in der Reihenfolge des Abonnierens auf. Die Website zeigt die neue Anzahl.
5. Das Lager prüft 10 < 3: nein, also tut es nichts.
6. Der Bestand ändert sich auf 2. Das Produkt geht die Liste durch und ruft jeden Abonnenten in der Reihenfolge des Abonnierens auf. Die Website zeigt die neue Anzahl.
7. Das Lager prüft 2 < 3: ja, also bestellt es nach.

Das ist Observer (Beobachter). Das Produkt ist das beobachtete Objekt (das Subject), und die Listener sind die Observer. Buttons in grafischen Programmen funktionieren genau so: „Beim Klick ruf das hier auf“.

Genauer, für Neugierige

• Du brauchst auch ein unsubscribe, das den Listener aus der Liste entfernt. Du entfernst dieselbe Funktion, die du abonniert hast, also hältst du sie in einer Variable. Ein Abonnent, den niemand entfernt, bleibt im Speicher, solange das Produkt lebt.

phone = Product("Telefon", 5)
site = lambda name, qty: print(f"Website: {qty} Stk.")
phone.subscribe(site)
phone.set_quantity(4)
phone.listeners.remove(site)
phone.set_quantity(3)
print("Die Website hört nicht mehr zu")

Ausgabe

Website: 4 Stk.
Die Website hört nicht mehr zu

• In der alten Vorlesung heißt die beobachtete Klasse Subject, mit den Methoden attach und notifyAllObservers, und der Observer ist eine abstrakte Klasse mit einer Methode update(). Die Idee ist dieselbe, und mit Funktionen brauchst du keine Klasse für jeden Observer.
• Die Listener werden nacheinander aufgerufen, innerhalb der Methode, die die Anzahl geändert hat. Ist einer von ihnen langsam, warten alle.

Probier es aus

Wer hört es?

Product ist das aus der Karte davor.

Was gibt das Programm aus?

coffee = Product("Kaffee", 5)
coffee.subscribe(lambda name, qty: print(f"A: {qty}"))
coffee.set_quantity(4)
coffee.set_quantity(4)
coffee.subscribe(lambda name, qty: print(f"B: {qty}"))
coffee.set_quantity(0)

Antwort

A: 4
A: 0

A: 4
B: 4
A: 0
B: 0

A: 4
A: 0
B: 0

A: 4
A: 4
A: 0
B: 0

Prüfen

Sieh es dir an

Factory Method: welche Klasse erzeugt wird

Der Kunde hat gewählt, wie wir ihn benachrichtigen: per E-Mail oder SMS. Der Code, der sendet, soll nicht an zehn Stellen EmailNotification() schreiben, jede mit ihrem eigenen if. Der Vertrag „Benachrichtigung“ ist eine abstrakte Klasse, wie im Modul „Vererbung und Polymorphie“:

from abc import ABC, abstractmethod


class Notification(ABC):
    @abstractmethod
    def send(self, to, text):
        pass


class EmailNotification(Notification):
    def send(self, to, text):
        print(f"E-Mail an {to}: {text}")


class SmsNotification(Notification):
    def send(self, to, text):
        print(f"SMS an {to}: {text}")

Die Wahl steht an einer Stelle, in einer Fabrik. Sie ist eine normale Funktion: In Java ist sie nur deshalb eine statische Methode in einer Klasse, weil dort alles in einer Klasse steht.

def create_notification(channel):
    match channel:
        case "email":
            return EmailNotification()
        case "sms":
            return SmsNotification()
        case _:
            raise ValueError(f"Unbekannter Kanal: {channel}")

customers = [
    ("email", "maria@example.com"),
    ("sms", "+49 151 2345678"),
    ("taube", "Hauptstraße 5"),
]
for channel, to in customers:
    try:
        n = create_notification(channel)
        n.send(to, "Deine Bestellung wurde versandt.")
    except ValueError as e:
        print(e)

Ausgabe

E-Mail an maria@example.com: Deine Bestellung wurde versandt.
SMS an +49 151 2345678: Deine Bestellung wurde versandt.
Unbekannter Kanal: taube

Der Aufrufer sagt, was er will („email“), und bekommt eine Notification. Welche Klasse genau dahintersteht, weiß nur die Fabrik. Ein neuer Kanal, zum Beispiel Push, ist eine neue Klasse und ein neuer Fall im match. Das Senden wird nicht angefasst.

Genauer, für Neugierige

• Das ist die häufigste Form in der Praxis. Ihr genauerer Name ist „einfache Fabrik“ (simple factory). Die Factory Method aus dem GoF-Buch ist etwas anderes: Die Basisklasse hat eine abstrakte Methode, die das Objekt erzeugt, und die Unterklassen entscheiden, welches:

class Shop(ABC):
    @abstractmethod
    def create_notification(self):
        pass

    def confirm_order(self, to):
        self.create_notification().send(to, "Die Bestellung ist eingegangen.")


class OnlineShop(Shop):
    def create_notification(self):
        return EmailNotification()


class PhoneShop(Shop):
    def create_notification(self):
        return SmsNotification()

OnlineShop().confirm_order("maria@example.com")
PhoneShop().confirm_order("+49 151 2345678")

Ausgabe

E-Mail an maria@example.com: Die Bestellung ist eingegangen.
SMS an +49 151 2345678: Die Bestellung ist eingegangen.

confirm_order ist einmal geschrieben, in Shop, und weiß nicht, welche Benachrichtigung es sendet. Und Shop() lässt sich nicht erzeugen: ABC hält es mit einem TypeError auf, weil create_notification abstrakt ist.

• Erreicht die Fabrik kein return, gibt sie None zurück. Dann kommt der Fehler erst bei send, weit weg von der eigentlichen Ursache:

def create_notification(channel):
    if channel == "email":
        return EmailNotification()
    if channel == "sms":
        return SmsNotification()


n = create_notification("taube")
try:
    n.send("Hauptstraße 5", "Deine Bestellung wurde versandt.")
except AttributeError as e:
    print("AttributeError:", e)

Ausgabe

AttributeError: 'NoneType' object has no attribute 'send'

Eine Exception mit einer klaren Meldung in der Fabrik ist besser.

Sieh es dir an

Singleton: nur ein Objekt

Die Einstellungen der Anwendung, etwa die Währung, werden einmal gelesen. Macht sich jeder Teil des Programms sein eigenes Einstellungsobjekt, werden sie viele Male gelesen und können auseinanderlaufen.

class AppConfig:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            print("Einstellungen werden gelesen...")
            cls._instance = super().__new__(cls)
            cls._instance.currency = "EUR"
        return cls._instance

a = AppConfig()
b = AppConfig()
print(a is b)
print(b.currency)

Ausgabe

Einstellungen werden gelesen...
True
EUR

• Python hat keinen private Konstruktor: Jeder kann AppConfig() schreiben. Darum steckt die Absicherung in __new__. Python ruft __new__ auf, um das Objekt zu erzeugen, noch vor __init__.
• Das einzige Objekt steht im Klassenfeld _instance. __new__ erzeugt es beim ersten Aufruf und gibt danach immer dieses zurück. Der Unterstrich im Namen sagt „für den internen Gebrauch“.
• Die Währung wird ebenfalls in __new__ gesetzt, nur beim ersten Mal. Warum nicht in __init__, steht in der Karte danach.
• „Einstellungen werden gelesen...“ erscheint einmal, und a is b ist True: Es gibt ein Objekt.

Das ist Singleton.

Genauer, für Neugierige

• Rufen zwei Threads AppConfig() im selben Moment auf, können zwei Objekte entstehen. Threads kommen im Modul „Programme in der echten Welt“.
• Ein sicherer Singleton in Python ist ein Enum mit einem Wert (das Modul enum). Ein Enum ist ein Typ mit vorab aufgezählten Objekten. Python erzeugt jedes genau einmal, und Settings("EUR") macht kein neues Objekt, sondern findet das aufgezählte:

from enum import Enum


class Settings(Enum):
    INSTANCE = "EUR"

    def currency(self):
        return self.value

print(Settings.INSTANCE.currency())
print(Settings("EUR") is Settings.INSTANCE)
try:
    Settings("USD")
except ValueError as e:
    print("ValueError:", e)

Ausgabe

EUR
True
ValueError: 'USD' is not a valid Settings

• In Python macht man häufiger etwas anderes: Das Objekt wird einmal erzeugt, auf der obersten Ebene eines Moduls, und die anderen Teile holen es mit import.
• Ein Singleton ist eine globale Variable für das ganze Programm mit einem schönen Namen. Jeder kann ihn von überall benutzen, darum ist er schwer zu testen und schwer zu ersetzen. Oft ist es besser, das Objekt einmal am Anfang des Programms zu erzeugen und es denen, die es benutzen, als Parameter zu übergeben.

Probier es aus

Finde den Fehler

Bestellnummern müssen eindeutig sein, darum ist der Zähler ein Singleton. Das Programm hat aber die Nummer 1001 zweimal vergeben:

numbers = OrderNumbers()
print(numbers.next_number())
print(numbers.next_number())
print(OrderNumbers().next_number())

Ausgabe

1001
1002
1001

In welcher Zeile der Klasse steckt der Fehler?

Wähle die Zeile mit dem Fehler.

1class OrderNumbers:2 _instance = None34 def __new__(cls):5 if cls._instance is None:6 cls._instance = super().__new__(cls)7 return cls._instance89 def __init__(self):10 self.next = 10011112 def next_number(self):13 number = self.next14 self.next += 115 return number

Prüfen

Sieh es dir an

Adapter: verbindet unverträgliche Interfaces

Der Shop bezahlt über ein Interface mit einem Betrag in Euro und einer Antwort „ja oder nein“. Die Bank gibt dir eine alte Bibliothek, die Cent will und einen Fehlercode zurückgibt. Die Bibliothek gehört nicht dir, und du kannst sie nicht ändern.

# Die alte Bibliothek der Bank. Du kannst sie nicht ändern.
class LegacyBankClient:
    # Der Betrag ist in Cent. Gibt bei Erfolg 0 zurück, sonst einen Fehlercode.
    def charge(self, cents, reference):
        print(f"Bank: {cents} Cent für {reference}")
        return 0 if cents <= 50000 else 51

Du schreibst eine Klasse, die so aussieht, wie der Shop es erwartet, und darin die Bank aufruft:

from abc import ABC, abstractmethod


# Das erwartet der Shop.
class PaymentGateway(ABC):
    @abstractmethod
    def pay(self, order_id, amount_eur):
        pass


class BankAdapter(PaymentGateway):
    def __init__(self, bank):
        self.bank = bank

    def pay(self, order_id, amount_eur):
        cents = round(amount_eur * 100)
        return self.bank.charge(cents, f"ORDER-{order_id}") == 0

gateway = BankAdapter(LegacyBankClient())
print(gateway.pay("1001", 49.90))
print(gateway.pay("1002", 1299.00))

Ausgabe

Bank: 4990 Cent für ORDER-1001
True
Bank: 129900 Cent für ORDER-1002
False

Der Adapter übersetzt in beide Richtungen: Euro in Cent und eine Nummer in Text auf dem Hinweg, Code 0 in true auf dem Rückweg. Der Shop weiß nicht, dass eine alte Bibliothek dahintersteht. Wechselst du morgen die Bank, schreibst du einen neuen Adapter, und der Shop wird nicht angefasst.

Das ist Adapter: wie ein Reisestecker-Adapter, der weder den Stecker noch die Steckdose verändert.

Genauer, für Neugierige

Das klassische Beispiel in den Büchern, und in der alten Vorlesung, ist ein Mediaplayer. AudioPlayer kann nur mp3 abspielen, und eine vorhandene Klasse AdvancedMediaPlayer hat die Methoden playVlc und playMp4. MediaAdapter implementiert das Interface des Players und leitet an die richtige Methode weiter. Die Struktur ist dieselbe wie hier.

Übung

Muster im Shop

Löse die Aufgaben in deinem Editor.

1. Rabatte als Strategien. Drei Funktionen, die ein Lambda zurückgeben: none(), percent(p) und fixed(amount) (nie unter 0 €). Eine Klasse Cart mit einer Liste von Preisen und einem austauschbaren Rabatt im Feld discount. Füge Kaffeebohnen (18,50 €), Honig (12 €) und Tee (4,20 €) hinzu und gib die Summe aus: ohne Rabatt, mit −10 %, mit −5 € und mit −50 €.

Ausgabe

Ohne Rabatt: 34.70 €
-10%: 31.23 €
-5 €: 29.70 €
-50 €: 0.00 €

2. „Benachrichtige mich, wenn es wieder da ist“. Das Produkt hält eine Liste von Kunden, die warten. Wenn der Bestand von 0 auf mehr als 0 geht, benachrichtigt es alle und leert die Liste, denn die Benachrichtigung kommt nur einmal. Die Konsole hat 0 Stück auf Lager, Maria und Jonas abonnieren, dann wird der Bestand 5, 0 und 3.

Ausgabe

E-Mail an Maria: Konsole ist verfügbar (5 Stk.)
SMS an Jonas: Konsole ist verfügbar
Ende

3. Eine Fabrik für Benachrichtigungen. Füge PushNotification hinzu und eine Fabrik für die drei Kanäle, der Groß- und Kleinschreibung egal ist. Lies eine Anzahl von Zeilen und dann Zeilen „Kanal;Adresse“. Schick an jede Adresse „Deine Reservierung ist bestätigt.“, und gib für einen unbekannten Kanal die Meldung der Exception aus.

Eingabe

4
Email;maria@example.com
sms;+49 151 2345678
push;Lauras Handy
fax;030 123456

Ausgabe

E-Mail an maria@example.com: Deine Reservierung ist bestätigt.
SMS an +49 151 2345678: Deine Reservierung ist bestätigt.
Push an Lauras Handy: Deine Reservierung ist bestätigt.
Unbekannter Kanal: fax

4. Ein altes Thermometer. Eine Klasse OldThermometer liefert die Temperatur in Fahrenheit mit read_fahrenheit(). Das neue System arbeitet mit einer abstrakten Klasse TemperatureSensor mit einer Methode celsius(). Schreib ThermometerAdapter (°C = (°F − 32) × 5 / 9). Leg in eine Liste von Sensoren zwei alte Thermometer (71,6 °F und 39,2 °F) über den Adapter und einen neuen Sensor DigitalSensor, der 21,5 °C liefert.

Ausgabe

Büro: 22.0 °C
Lager: 4.0 °C
Serverraum: 21.5 °C

Weitere Aufgaben

• Lieferung als Strategie. Mach Funktionen für den Lieferpreis zur Packstation, an die Haustür und ab dem Laden, und setz die gewählte zusammen mit dem Rabatt in die Kasse.
• Ein Log als Singleton. Eine Klasse Logger mit einem __new__, das das einzige Objekt hält, und einer Methode log(text), die die Zeilen nummeriert. Prüf, dass die Nummern weiterlaufen, wenn du sie aus zwei verschiedenen Funktionen aufrufst.
• Ein Preis-Observer. Füge dem Produkt Abonnenten für Preisänderungen hinzu und schick eine Benachrichtigung nur, wenn der Preis um mindestens 10 % fällt.

Test

Teste dich

1. Was ist ein Entwurfsmuster?

Eine fertige Bibliothek, die du ins Projekt einbindestEine Regel des InterpretersEine bewährte Lösung mit Namen für ein Problem, das immer wieder vorkommt: eine Idee, wie man die Klassen und Funktionen anordnet

2. Jede neue Aktion im Shop fügt der Preisfunktion ein neues elif hinzu. Welches Muster hilft?

SingletonAdapterStrategy: Jeder Rabatt ist eine eigene Funktion, und die Kasse bekommt gesagt, welche sie nehmen soll

3. Das Produkt sagt der Website, dem Lager und dem E-Mail-System Bescheid, wenn sich der Bestand ändert, ohne zu wissen, wer sie sind. Welches Muster ist das?

SingletonObserverFactory Method

4. Ein Singleton mit einem __new__, das das schon erzeugte Objekt zurückgibt, hat auch ein __init__, das self.next = 1001 setzt. Was passiert beim zweiten OrderNumbers()?

Das Objekt ist dasselbe, aber __init__ läuft noch einmal und setzt den Zähler auf 1001 zurückEs entsteht ein zweites ObjektNichts: Das Objekt ist dasselbe

5. Du hast eine alte Klasse, die die Temperatur in Fahrenheit liefert, und das Programm erwartet einen Sensor mit einer Methode celsius(). Was tust du?

Die alte Klasse neu schreibenAdapter: eine neue Klasse mit einer Methode celsius(), die darin die alte aufruft und die Werte umrechnetFactory Method

Prüfen

Die Idee

Weiter: die Muster aus der Nähe

Hier hast du fünf Muster kurz gesehen, mit Lambdas. Im Kurs „Softwaretechnik“ gibt es ein ganzes Modul über Muster: Jedes beginnt mit Code, der wehtut, hat eine Animation, welches Objekt welches aufruft, und sagt, wann du es nicht brauchst. Dort sind auch Builder, Decorator, Composite, Command, State, Template Method, Iterator und Repository.

Das Modul ist hier: Entwurfsmuster.

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Listen: append, remove und sort · Klassen und Daten in Klassen · Lambdas · dataclass, match und Muster
• Geht weiter in: Warum Muster · Strategy · Observer · Factory Method und Simple Factory
• Aufgaben zum Thema: Modernes Python