Python Academy · Lektion

Sequenzen und Mappings abgleichen

Listen und Dicts destrukturieren

Sequenzen und Mappings abgleichen ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Patterns mit Destrukturierung

Die eigentliche Stärke von match ist die Destrukturierung. Sequenz- und Mapping-Patterns ermöglichen es, die Struktur von Daten zu prüfen und gleichzeitig Werte daraus zu entnehmen.

Eine Liste fester Länge abgleichen

Ein Sequenz-Pattern in eckigen Klammern passt auf eine Liste oder ein Tupel mit genau dieser Länge und bindet jedes Element an einen Namen.

point = [3, 4]

match point:
    case [x, y]:
        print('x =', x, 'y =', y)

Die Länge muss übereinstimmen

Ein Pattern mit zwei Elementen passt nicht auf eine Sequenz mit drei Elementen. Jeder Case prüft sowohl die Struktur als auch die Länge.

data = [1, 2, 3]

match data:
    case [a, b]:
        print('pair')
    case [a, b, c]:
        print('triple:', a, b, c)

Literale und Captures kombinieren

Sie können einige Positionen auf Literale festlegen und andere erfassen. Dadurch passen nur Sequenzen, die mit dem angegebenen Literal beginnen.

command = ['move', 10, 20]

match command:
    case ['move', dx, dy]:
        print('moving by', dx, dy)
    case ['stop']:
        print('stopping')

Den Rest mit * erfassen

Ein Name mit vorangestelltem * erfasst alle verbleibenden Elemente als Liste – ähnlich wie beim erweiterten Entpacken.

items = [1, 2, 3, 4, 5]

match items:
    case [first, *rest]:
        print('first:', first)
        print('rest:', rest)

Leere und einzelne Patterns

Sequenz-Patterns behandeln Sonderfälle übersichtlich: eine leere Liste, ein einzelnes Element oder viele Elemente.

def describe(seq):
    match seq:
        case []:
            return 'empty'
        case [x]:
            return 'one: ' + str(x)
        case [x, *rest]:
            return 'many, first ' + str(x)

print(describe([]))
print(describe([9]))
print(describe([1, 2, 3]))

Wörterbücher abgleichen

Ein Mapping-Pattern verwendet geschweifte Klammern. Es prüft, ob die angegebenen Schlüssel vorhanden sind, und bindet ihre Werte. Zusätzliche Schlüssel im Prüfwert sind erlaubt.

event = {'type': 'click', 'x': 10, 'y': 20}

match event:
    case {'type': 'click', 'x': x, 'y': y}:
        print('click at', x, y)

Partieller Schlüsselabgleich

Ein Mapping-Pattern erfordert nur die von Ihnen aufgelisteten Schlüssel. Andere Schlüssel werden ignoriert, was sich besonders für Nachrichten mit optionalen Feldern eignet.

event = {'type': 'key', 'code': 'A', 'extra': 1}

match event:
    case {'type': 'key', 'code': code}:
        print('key pressed:', code)

Verbleibende Schlüssel erfassen

Verwenden Sie **rest, um alle nicht abgeglichenen Schlüssel-Wert-Paare in einem Wörterbuch zu erfassen.

event = {'type': 'move', 'dx': 5, 'dy': 7}

match event:
    case {'type': 'move', **rest}:
        print('move details:', rest)

Patterns verschachteln

Patterns lassen sich beliebig verschachteln. Sie können ein Wörterbuch abgleichen, das eine Liste enthält, und dabei beides gleichzeitig destrukturieren.

data = {'name': 'grid', 'size': [3, 4]}

match data:
    case {'name': name, 'size': [w, h]}:
        print(name, 'is', w, 'by', h)

Zeichenketten sind hier keine Sequenzen

Sequenz-Patterns passen absichtlich nicht auf Zeichenketten oder Bytes, obwohl diese iterierbar sind. So wird verhindert, dass eine Zeichenkette versehentlich Zeichen für Zeichen destrukturiert wird.

value = 'hi'

match value:
    case [a, b]:
        print('matched as sequence')
    case str():
        print('matched as string')

Kurze Überprüfung

Was binden [first, *rest] beim Abgleich mit [1, 2, 3, 4]?

Zusammenfassung

Sie haben gelernt, Listen und Wörterbücher zu destrukturieren.

Sequenz-Patterns prüfen die Länge und binden Elemente.
*rest erfasst die verbleibenden Listenelemente.
Mapping-Patterns gleichen Schlüssel ab; zusätzliche Schlüssel sind erlaubt.
**rest erfasst die verbleibenden Wörterbuch-Paare; Patterns lassen sich verschachteln.

Häufig gestellte Fragen

Ist die Lektion „Sequenzen und Mappings abgleichen“ kostenlos?

Ja — der vollständige Text von „Sequenzen und Mappings abgleichen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Sequenzen und Mappings abgleichen“?

Listen und Dicts destrukturieren Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Sequenzen und Mappings abgleichen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy