classmethod()

Einleitung

Python kennt drei Arten von Methoden:

• Instanz-Methode (Default): bekommt self — die konkrete Instanz.
• Klassen-Methode (@classmethod): bekommt cls — die Klasse selbst.
• Statische Methode (@staticmethod): bekommt nichts Implizites.

Klassen-Methoden glänzen bei Factory-Funktionen, die je nach Kontext eine andere Subklasse erzeugen sollen. Da cls der konkrete Typ ist (nicht die fest codierte Oberklasse), funktionieren sie auch in Subklassen korrekt.

classmethod() wird heutzutage als Decorator verwendet (@classmethod), kann aber auch direkt als Funktion aufgerufen werden — relevant für dynamisch generierte Klassen.

Syntax

class MyClass:
    @classmethod
    def my_method(cls, ...):
        ...

Rückgabewert

Eine classmethod-Wrapper-Instanz, die beim Attribut-Zugriff einen gebundenen Aufrufer liefert.

Beispiele

Factory-Methode

Der häufigste Use-Case: eine alternative Form der Instanziierung — from_*-Factory-Methoden:

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, s):
        year, month, day = map(int, s.split("-"))
        return cls(year, month, day)

    def __repr__(self):
        return f"Date({self.year}, {self.month}, {self.day})"

print(Date.from_string("2026-05-03"))

Date(2026, 5, 3)

Subklassen-freundlich

Da cls die konkrete Klasse ist, liefert die Factory automatisch eine Instanz der richtigen Subklasse:

class Holiday(Date):
    pass

h = Holiday.from_string("2026-12-24")
print(type(h).__name__, h)

Holiday Date(2026, 12, 24)

Aufruf auf Klasse oder Instanz

Klassen-Methoden funktionieren in beide Richtungen — der Aufrufer bestimmt die Lesbarkeit:

class Counter:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1
        return cls.count

print(Counter.increment())   # auf Klasse
c = Counter()
print(c.increment())          # auf Instanz — gleiches Verhalten

1
2

Praktische Beispiele

Verschiedene Konstruktoren parallel anbieten

Eine Klasse kann mehrere from_*-Methoden haben — der __init__ bleibt der „kanonische" Pfad, die Factories sind Convenience:

class Color:
    def __init__(self, r, g, b):
        self.r, self.g, self.b = r, g, b

    @classmethod
    def from_hex(cls, s):
        s = s.lstrip("#")
        return cls(int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16))

    @classmethod
    def from_tuple(cls, t):
        return cls(*t)

    def __repr__(self):
        return f"Color({self.r}, {self.g}, {self.b})"

print(Color.from_hex("#0a8ea1"))
print(Color.from_tuple((255, 0, 0)))

Color(10, 142, 161)
Color(255, 0, 0)

Klassen-Counter (Registry-Pattern)

Klassen-Methoden eignen sich hervorragend, um Klassen-weite Zustände zu verwalten — z. B. eine Plugin-Registry:

class Plugin:
    registry = []

    def __init_subclass__(cls):
        Plugin.registry.append(cls)

    @classmethod
    def all_plugins(cls):
        return [p.__name__ for p in cls.registry]

class A(Plugin): pass
class B(Plugin): pass
class C(Plugin): pass

print(Plugin.all_plugins())

['A', 'B', 'C']

Praktische Hinweise

• Factory-Methoden sind das Schulbuch-Beispiel — from_*-Konvention im Methodennamen.
• cls(...) statt MyClass(...) sorgt dafür, dass Subklassen automatisch die richtige Klasse bekommen.
• Versus staticmethod: Wenn die Methode cls braucht — classmethod. Wenn nicht — staticmethod oder einfache Funktion.
• Versus __init__: Mehrere Konstruktoren elegant trennbar — der Hauptkonstruktor bleibt einfach.
• Verwandte Decorators: @staticmethod, @property, @functools.singledispatchmethod.