Klassenmuster
Objektattribute abgleichen
Klassenmuster ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Objekte abgleichen
Klassen-Patterns ermöglichen es match, den Typ eines Objekts zu prüfen und seine Attribute in einem Schritt zu entnehmen. Sie sehen innerhalb eines Cases wie ein Konstruktoraufruf aus.
Nur den Typ prüfen
Ein Klassen-Pattern mit leeren Klammern passt auf jede Instanz dieser Klasse.
def kind(value):
match value:
case int():
return 'an integer'
case str():
return 'a string'
case _:
return 'something else'
print(kind(5))
print(kind('hi'))
print(kind([1]))Attribute anhand ihres Namens erfassen
Schreiben Sie innerhalb der Klammern attr=name, um Instanzen abzugleichen und das benannte Attribut an eine Variable zu binden.
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
p = Point(3, 4)
match p:
case Point(x=px, y=py):
print('point at', px, py)Bestimmte Attributwerte abgleichen
Sie können verlangen, dass ein Attribut einem Literal entspricht. Dieser Case passt nur auf Punkte, die auf der x-Achse liegen.
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
def describe(p):
match p:
case Point(x=0, y=0):
return 'origin'
case Point(x=x, y=0):
return 'on x-axis at ' + str(x)
case Point():
return 'elsewhere'
print(describe(Point(0, 0)))
print(describe(Point(5, 0)))
print(describe(Point(1, 1)))Positions-Patterns mit __match_args__
Wenn eine Klasse __match_args__ definiert, können Sie Attribute nach ihrer Position abgleichen. Dataclasses setzen dies automatisch anhand der Reihenfolge ihrer Felder.
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
p = Point(3, 4)
match p:
case Point(px, py):
print(px, py)__match_args__ manuell definieren
Setzen Sie bei einer normalen Klasse __match_args__ auf ein Tupel, das die Attribute benennt, die positionsabhängig verfügbar sein sollen.
class Point:
__match_args__ = ('x', 'y')
def __init__(self, x, y):
self.x = x
self.y = y
match Point(1, 2):
case Point(a, b):
print(a, b)Nach Klassen dispatchen
Klassen-Patterns ermöglichen einen übersichtlichen Dispatcher für eine Gruppe verwandter Typen, wobei jeder Typ in seinem eigenen Case behandelt wird.
from dataclasses import dataclass
@dataclass
class Circle:
radius: float
@dataclass
class Square:
side: float
def area(shape):
match shape:
case Circle(radius=r):
return 3.14159 * r * r
case Square(side=s):
return s * s
print(area(Circle(2)))
print(area(Square(3)))Klassen-Patterns verschachteln
Klassen-Patterns lassen sich verschachteln. Ein Feld, das selbst ein Objekt ist, kann mit einem weiteren Klassen-Pattern abgeglichen werden.
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
@dataclass
class Line:
start: Point
end: Point
line = Line(Point(0, 0), Point(3, 4))
match line:
case Line(start=Point(x=0, y=0), end=Point(x=ex, y=ey)):
print('from origin to', ex, ey)Mit eingebauten Typen kombinieren
Eingebaute Typen unterstützen ein einzelnes Positionsargument, das den Wert erfasst. int(n) passt auf ein int und bindet es an n.
def label(value):
match value:
case int(n):
return 'int ' + str(n)
case str(s):
return 'str ' + s
case _:
return 'other'
print(label(7))
print(label('hi'))Wann Sie Klassen-Patterns verwenden sollten
Verwenden Sie Klassen-Patterns, wenn sowohl der Typ eines Objekts als auch seine Attributwerte die Logik bestimmen, etwa bei Event-Objekten, AST-Knoten oder Formhierarchien. Sie ersetzen ausführliche isinstance-Prüfungen zusammen mit dem Zugriff auf Attribute.
Positionale und Schlüsselwort-Patterns kombinieren
Sie können in einem Klassen-Pattern positionale und Schlüsselwort-Subpatterns kombinieren, genau wie bei einem Funktionsaufruf. Positionale Patterns verwenden die Reihenfolge aus __match_args__; Schlüsselwort-Patterns benennen das Attribut ausdrücklich.
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
z: int
p = Point(1, 2, 3)
match p:
case Point(x, y, z=depth):
print(x, y, depth)Kurze Überprüfung
Auf welche Objekte passt das Pattern Point(x=0, y=y)?
Zusammenfassung
Sie haben gelernt, anhand von Objektattributen abzugleichen.
ClassName()prüft den Typ.attr=namebindet Attribute; Literale erfordern exakte Werte.__match_args__ermöglicht positionsabhängiges Matching.- Klassen-Patterns lassen sich verschachteln und ermöglichen Dispatching über Typhierarchien.
Häufig gestellte Fragen
Ist die Lektion „Klassenmuster“ kostenlos?
Ja — der vollständige Text von „Klassenmuster“ 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 „Klassenmuster“?
Objektattribute abgleichen 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 3 von 4.
Wie lange dauert die Lektion „Klassenmuster“?
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.