Zum Inhalt springen
aviral gupta
Kontakt aufnehmen

// B2.4 · ca. 30 Min. · Einstieg

Mustervergleich mit match

Nach dieser Lektion wählen Sie mit match zwischen Fällen, zerlegen eine Liste mit Mustern, die ihre Elemente einfangen, und ergänzen Bedingungen mit Guards.

Lektion 4 von 5 in B2 Kontrollfluss

Danach können Sie

  • Einen Wert mit Literalen, mit | verbundenen Alternativen und dem Platzhalter _ vergleichen
  • Eine Liste mit Sequenzmustern und Fangnamen zerlegen, auch mit *rest
  • Guards mit if ergänzen und Dictionaries und Typen mit Mapping- und Klassenmustern prüfen

  1. Aufwärmen · Aufgabe 1 von 7

    Aufwärmen aus B2.3: Was gibt das aus?

    for n in [1, 3, 5]:
    if n % 2 == 0:
        print("even:", n)
        break
else:
    print("no even number")

  2. Vorhersagen · Aufgabe 2 von 7

    Sagen Sie es vorher, bevor Sie weiterlesen: Was gibt das aus?

    status = 418

match status:
    case 200:
        print("OK")
    case 404:
        print("Not found")
    case _:
        print("Other")

  3. Üben · Aufgabe 3 von 7

    Setzen Sie das Zeichen ein, mit dem ein Fall auf "sat" oder "sun" passt.

    day = "sun"

match day:
    case "sat" ____ "sun":
        print("weekend")
    case _:
        print("weekday")
    case "sat" "sun":

  4. Üben · Aufgabe 4 von 7

    split() macht aus dem Text eine Liste von Wörtern. Was gibt das aus?

    command = "go north".split()

match command:
    case ["quit"]:
        print("bye")
    case ["go", direction]:
        print("going", direction)
    case _:
        print("unknown")

  5. Üben · Aufgabe 5 von 7

    Ordnen Sie jedem Muster zu, worauf es passt.

  6. Denksport · Aufgabe 6 von 7

    Knobelaufgabe. QUIT soll eine Konstante sein. Was gibt das aus?

    QUIT = "q"
key = "x"

match key:
    case QUIT:
        print("quitting", QUIT)

  7. Anwenden · Aufgabe 7 von 7

    Mini-Aufgabe. Schreiben Sie einen kleinen Rechner: Lesen Sie eine Zeile mit input(), zerlegen Sie sie und vergleichen Sie die Wörter mit match. add 2 3 gibt 5 aus, neg 4 gibt -4 aus, quit gibt bye aus, alles andere unknown command. Wandeln Sie die eingefangenen Wörter mit int() um.

    Prüfen Sie Ihr Ergebnis anhand dieser Liste

Selbst programmieren

Lesen Sie das ausgearbeitete Beispiel und lösen Sie dann die Übungen. Ihr Code läuft in Ihrem Browser oder auf Ihrem Computer und wird nie hochgeladen.

Ausgearbeitetes Beispiel

Befehle für ein Textspiel

Ein Textabenteuer liest Befehle wie go north oder take lamp key. Das Programm zerlegt jeden Befehl in Wörter und vergleicht die Liste: feste Befehle, ein Guard, der nur vier Richtungen erlaubt, *things für beliebig viele Gegenstände, | für zwei Schreibweisen und ein Platzhalter für alles andere. Ergänzen Sie eigene Befehle in der Liste und starten Sie es erneut.

main.py

# A few commands a player might type.
commands = ["look", "go north", "go up", "take lamp key", "i", "", "dance now"]
inventory = []

for line in commands:
    match line.split():
        case ["look"]:
            print("You are in a dark hall.")
        case ["go", direction] if direction in ["north", "south", "east", "west"]:
            print("You walk", direction)
        case ["go", other]:
            print("You cannot go", other)
        case ["take", *things]:
            for thing in things:
                inventory.append(thing)
            print("Taken:", things)
        case ["inventory" | "i"]:
            print("You carry:", inventory)
        case []:
            print("Say something.")
        case [verb, *_]:
            print("I do not know how to", verb)

Ausführen mit

python main.py

Ausgabe

You are in a dark hall.
You walk north
You cannot go up
Taken: ['lamp', 'key']
You carry: ['lamp', 'key']
Say something.
I do not know how to dance
  • go up scheitert am Guard des ersten go-Falls, also probiert match den nächsten Fall, ["go", other].
  • *things sammelt jedes Wort nach take, hier zwei, in einer Liste.
  • "".split() ist die leere Liste, auf die case [] passt.
  • case [verb, *_] fängt jeden anderen nicht leeren Befehl ab und behält nur das erste Wort.
Ändern und ausführen

Tab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.

Beim ersten Ausführen lädt Ihr Browser Python herunter (bis zu 6.5 MB) und speichert es im Cache. Ihr Code bleibt auf Ihrem Gerät.

Übungen

Übung 1 von 2

HTTP-Statustext

Das Programm liest einen HTTP-Statuscode als ganze Zahl. Geben Sie mit match OK für 200 aus, Redirect für 301 oder 302, Not found für 404, Server error für 500 und Unknown für alles andere. Fassen Sie 301 und 302 mit | in einem Fall zusammen.

Tab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.

Beim ersten Ausführen lädt Ihr Browser Python herunter (bis zu 6.5 MB) und speichert es im Cache. Ihr Code bleibt auf Ihrem Gerät.

Hinweise
  1. Hinweis 1

    match code: mit einem Fall pro Status, jeweils mit eingerücktem print.

  2. Hinweis 2

    case 301 | 302: passt auf beide Codes.

  3. Hinweis 3

    Schließen Sie mit case _: print("Unknown") als letztem Fall ab.

Eine Lösung zeigen

Ein möglicher Lösungsweg. Ihrer kann anders aussehen und trotzdem alle Prüfungen bestehen.

code = int(input())

match code:
    case 200:
        print("OK")
    case 301 | 302:
        print("Redirect")
    case 404:
        print("Not found")
    case 500:
        print("Server error")
    case _:
        print("Unknown")
Auf dem eigenen Computer ausführen

Installieren Sie Python 3.14 oder neuer. Speichern Sie diese Dateien in einem Ordner, öffnen Sie dort ein Terminal und führen Sie die Befehle unten aus.

main.py

code = int(input())

# Match code and print its text.
print("Unknown")

test_main.py

from learnrun import run_main


def status(code):
    return run_main(f"{code}\n").strip()


def test_ok_and_not_found():
    """200 ist OK und 404 ist Not found"""
    got = status(200), status(404)
    assert got == ("OK", "Not found"), f"bei 200 und 404 gab das Programm {got!r} aus"


def test_redirects():
    """301 und 302 sind beide Redirect"""
    got = status(301), status(302)
    assert got == ("Redirect", "Redirect"), f"bei 301 und 302 gab das Programm {got!r} aus"


def test_server_error():
    """500 ist Server error"""
    got = status(500)
    assert got == "Server error", f"bei 500 gab das Programm {got!r} aus, erwartet: 'Server error'"


def test_unknown():
    """Jeder andere Code ist Unknown"""
    got = status(418)
    assert got == "Unknown", f"bei 418 gab das Programm {got!r} aus, erwartet: 'Unknown'"

Unter macOS und Linux tippen Sie python3, wo in diesen Befehlen python steht, wie in der ersten Lektion.

Programm ausführen:

python main.py

Prüfungen ausführen (learnrun.py muss im selben Ordner liegen):

python learnrun.py test
learnrun.py herunterladen

Übung 2 von 2

Fläche einer Form

Das Programm liest eine Zeile wie square 5 oder rect 3 4. Zerlegen Sie sie und vergleichen Sie die Wörter mit match. Geben Sie die Fläche eines Quadrats oder Rechtecks als ganze Zahl aus. Ist eine Größe nicht über 0, geben Sie mit einem Guard invalid aus. Bei allem anderen unknown shape.

Tab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.

Beim ersten Ausführen lädt Ihr Browser Python herunter (bis zu 6.5 MB) und speichert es im Cache. Ihr Code bleibt auf Ihrem Gerät.

Hinweise
  1. Hinweis 1

    case ["square", side]: fängt die Größe als String ein; int(side) macht daraus eine Zahl.

  2. Hinweis 2

    Ein Guard steht hinter dem Muster: case ["square", side] if int(side) > 0:.

  3. Hinweis 3

    Nach den Fällen mit Guard fängt case ["square", _] | ["rect", _, _]: die richtigen Formen mit falschen Größen ab.

Eine Lösung zeigen

Ein möglicher Lösungsweg. Ihrer kann anders aussehen und trotzdem alle Prüfungen bestehen.

words = input().split()

match words:
    case ["square", side] if int(side) > 0:
        print(int(side) * int(side))
    case ["rect", width, height] if int(width) > 0 and int(height) > 0:
        print(int(width) * int(height))
    case ["square", _] | ["rect", _, _]:
        print("invalid")
    case _:
        print("unknown shape")
Auf dem eigenen Computer ausführen

Installieren Sie Python 3.14 oder neuer. Speichern Sie diese Dateien in einem Ordner, öffnen Sie dort ein Terminal und führen Sie die Befehle unten aus.

main.py

words = input().split()

# Match words: ["square", side] or ["rect", width, height].
print("unknown shape")

test_main.py

from learnrun import run_main


def area(line):
    return run_main(line + "\n").strip()


def test_square():
    """square 5 hat die Fläche 25"""
    got = area("square 5")
    assert got == "25", f"bei square 5 gab das Programm {got!r} aus, erwartet: '25'"


def test_rect():
    """rect 3 4 hat die Fläche 12"""
    got = area("rect 3 4")
    assert got == "12", f"bei rect 3 4 gab das Programm {got!r} aus, erwartet: '12'"


def test_invalid_sizes():
    """Größen von 0 oder weniger sind invalid"""
    got = area("square 0"), area("rect 3 -1")
    assert got == ("invalid", "invalid"), f"bei square 0 und rect 3 -1 gab das Programm {got!r} aus"


def test_unknown():
    """Andere Formen und falsche Wortzahlen sind unknown"""
    got = area("circle 2"), area("rect 3")
    assert got == ("unknown shape", "unknown shape"), f"bei circle 2 und rect 3 gab das Programm {got!r} aus"

Unter macOS und Linux tippen Sie python3, wo in diesen Befehlen python steht, wie in der ersten Lektion.

Programm ausführen:

python main.py

Prüfungen ausführen (learnrun.py muss im selben Ordner liegen):

python learnrun.py test
learnrun.py herunterladen

Häufige Fehler

Ein bloßer Name als Konstante

QUIT = "q"
key = "x"
match key:
    case QUIT:
        print("quitting")
    case _:
        print("other key")

Was Python ausgibt

SyntaxError: name capture 'QUIT' makes remaining patterns unreachable

Warum, und die Lösung

Ein bloßer Name in einem case fängt jeden Wert ein, kein Fall danach könnte je laufen, und Python lehnt die Datei ab. Vergleichen Sie stattdessen mit dem Literal: case "q":. Benannte Konstanten funktionieren nur als Namen mit Punkt, etwa keys.QUIT; die lernen Sie mit Modulen und Klassen kennen.

or statt |

day = "sat"
match day:
    case "sat" or "sun":
        print("weekend")

Was Python ausgibt

SyntaxError: invalid syntax

Warum, und die Lösung

Muster sind keine Ausdrücke, or ist darin also nicht erlaubt. Alternativen verbinden Sie mit einem senkrechten Strich: case "sat" | "sun":.

Der Platzhalter zuerst

n = 1
match n:
    case _:
        print("anything")
    case 1:
        print("one")

Was Python ausgibt

SyntaxError: wildcard makes remaining patterns unreachable

Warum, und die Lösung

case _: passt auf alles, und match hört beim ersten passenden Fall auf; kein Fall darunter könnte je laufen. Stellen Sie die genauen Fälle nach oben und den Platzhalter ans Ende, so wie else am Ende einer if-Kette steht.

Python im Browser: Pyodide 314.0.7, MPL-2.0. Lizenz und Quellcode

Abschlussquiz

5 Fragen, ohne Hinweise. Ab 80 % ist die Lektion abgeschlossen.

Erledigen Sie zuerst alle Aufgaben oben, um das Abschlussquiz freizuschalten.

Problem melden

Etwas ist falsch oder unklar? Beschreiben Sie es kurz, dann wird es geprüft und korrigiert.

#

Mindestens 20 Zeichen.

Nur, wenn Sie eine Antwort wünschen.

Kernideen

match probiert die Fälle von oben

match value: vergleicht den Wert der Reihe nach mit jedem case-Muster und führt nur den ersten passenden Fall aus, wie eine if- und elif-Kette. Ein Literal wie case 404: oder case "quit": passt auf einen gleichen Wert. case 401 | 403: passt auf beide. case _: ist der Platzhalter: Er passt auf alles, steht darum am Ende und wirkt wie else. Ohne ihn läuft bei einem Wert ohne passenden Fall nichts, und es gibt keinen Fehler. Ein case _: ohne Guard, das nicht zuletzt steht, lehnt Python ab.

Sequenzmuster und Fangnamen

Ein Muster kann wie eine Liste aussehen: case ["go", direction]: passt auf eine Liste mit genau zwei Elementen, deren erstes "go" ist, und bindet das zweite an den Namen direction. Ein bloßer Name ist ein Fangmuster: Er passt auf alles und weist es zu. case QUIT: vergleicht also nicht mit einer Variablen QUIT. case [first, *rest]: passt auf eine Liste mit mindestens einem Element; rest bekommt die übrigen als Liste. Strings gelten nicht als Sequenzen, darum macht text.split() aus einer Zeile erst eine Wortliste.

Guards, Dictionaries und Typen

Ein Guard ergänzt eine Bedingung: case [x, y] if x == y: passt nur, wenn das Muster passt und die Bedingung wahr ist; sonst probiert match den nächsten Fall. Ein Mapping-Muster passt auf ein Dictionary, einen Typ aus einem späteren Modul: case {"type": "click", "x": x}: braucht diese Schlüssel und ignoriert alle anderen. Ein Klassenmuster prüft den Typ: case int(): passt auf jede ganze Zahl, auch auf True und False, case str(): auf jeden String. Mit Argumenten wie Point(x=0) arbeiten sie, sobald Sie Klassen schreiben.

Quellen

Zuletzt geprüft am 29. September 2026