Statische Methoden kannst du direkt über den Klas­sen­na­men aufrufen, ohne eine Instanz der Klasse erstellen zu müssen. Python sta­tic­me­thod un­ter­stützt dich dabei, die Klas­sen­lo­gik sauber von den In­stanz­da­ten zu trennen.

Wozu dient Python sta­tic­me­thod?

Python sta­tic­me­thod fungiert als Funktion und Dekorator, um Methoden zu markieren, die un­ab­hän­gig von Klas­sen­in­stan­zen agieren. De­ko­ra­to­ren in Python sind Werkzeuge, die das Verhalten anderer Methoden anpassen, indem sie zu­sätz­li­che Funk­tio­na­li­tät vor oder nach deren Aus­füh­rung ergänzen, ohne den ei­gent­li­chen Code zu verändern. Im Gegensatz zu In­stanz­me­tho­den benötigen statische Funk­tio­nen keinen im­pli­zi­ten Parameter wie self für Instanzen.

Der Einsatz von sta­tic­me­thod in Python erlaubt es dir, Funk­tio­nen innerhalb von Klassen zu struk­tu­rie­ren, die keine In­stanz­da­ten benötigen. Da keine Bindung an eine Instanz besteht, können sie den Zustand eines Objekts nicht ändern. Sie sind praktisch, um innerhalb einer Klasse all­ge­mei­ne Aufgaben zu erledigen oder globale Funk­tio­nen be­reit­zu­stel­len. Das können zum Beispiel Dienst­pro­gram­me, Kon­ver­tie­run­gen oder Hilfs­funk­tio­nen sein, die ohne In­stanz­da­ten glatt laufen.

So sieht die Syntax von Python sta­tic­me­thod aus

In Python hast du zwei Wege, um statische Methoden zu de­fi­nie­ren. Nutze dafür entweder die staticmethod()-Funktion oder den Dekorator @staticmethod.

staticmethod()

staticmethod() ist eine in­te­grier­te Python-Funktion, die eine Methode einer Klasse statisch macht. Der Rück­ga­be­wert von Python staticmethod() ist eine statische Methode der als Argument über­ge­be­nen Funktion. Die Syntax sieht so aus:

class Class:
    def staticmethodFunc(x,y):
        return x + y
Class.staticmethodFunc = staticmethod(Class.staticmethodFunc)
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12
python

Indem die in der Klasse Class de­fi­nier­te Funktion staticmethodFunc() als Argument an staticmethod() geht, lässt sich die eigene Methode direkt über den Klas­sen­na­men an­spre­chen.

@staticmethod

Der @staticmethod-Dekorator ist der schnel­le­re und gängigere Weg, eine Funktion statisch zu markieren. Du plat­zierst den Dekorator einfach über der Methode innerhalb der Klas­sen­de­fi­ni­ti­on. Die Syntax lautet:

class Class:
    @staticmethod
    def staticmethodFunc(x, y):
        return x + y
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12
python

Der Dekorator @staticmethod zeigt dem In­ter­pre­ter, dass die Funktion als statische Methode behandelt werden soll.

Code­bei­spie­le für den Einsatz von Python sta­tic­me­thod

Statische Methoden sind für viele Aufgaben nützlich. Hier findest du ein paar pra­xis­na­he Beispiele.

Kon­ver­tie­ren von Einheiten

Python sta­tic­me­thod eignet sich her­vor­ra­gend für die Um­rech­nung von Einheiten.

class Converter:
    @staticmethod
    def hoursToMinutes(hours):
        return hours * 60
    @staticmethod
    def minutesToHours(minutes):
        return minutes / 60
hours = 3
converted_minutes = Converter.hoursToMinutes(hours)
print(f"{hours} hours are {converted_minutes} minutes.") # Output: 3 hours are 180 minutes.
minutes = 180
converted_hours = Converter.minutesToHours(minutes)
print(f"{minutes} minutes are {converted_hours} hours.") # Output: 180 minutes are 3 hours.
python

In diesem Fall nutzt die Klasse Converter zwei statische Methoden für Zeit­um­rech­nun­gen. Die Methode hoursToMinutes() macht aus Stunden Minuten, während minutesToHours() den um­ge­kehr­ten Weg geht.

Die sta­ti­schen Methoden werden über den Klas­sen­na­men auf­ge­ru­fen, ganz ohne Instanz. Der Zugriff erfolgt via Converter.hoursToMinutes() oder Converter.minutesToHours(), wobei Converter der Name der Klasse ist. Die Ausgabe erfolgt als f-String – eine ef­fi­zi­en­te Python-String-Format-Methode zur Ver­knüp­fung von Aus­drü­cken.

Hilfs­funk­tio­nen für ma­the­ma­ti­sche Be­rech­nun­gen

Mit Python sta­tic­me­thod lassen sich auch prima Hilfs­funk­tio­nen für Kal­ku­la­tio­nen erstellen.

class Calculator:
    @staticmethod
    def square(x):
        return x * x
    @staticmethod
    def sqroot(x):
        return x ** 0.5
num = 9
square = Calculator.square(num)
print(f"The square of {num} is {square}.") # Output: The square of 9 is 81.
root = Calculator.sqroot(num)
print(f"The square root of {num} is {root}.") # Output: The square root of 9 is 3.
python

Dieses Beispiel zeigt die Klasse Calculator mit sta­ti­schen Methoden für Quadrate und Wurzeln. Mit dem @staticmethod-Dekorator werden square() und sqroot() als statisch definiert. Ohne Umweg über eine Instanz werden die Methoden über die Klasse auf­ge­ru­fen. Die Er­geb­nis­se von Calculator.square() und Calculator.sqroot() werden im f-String zu­sam­men­ge­führt.

Va­li­die­rung von Eingaben

Auch für die Über­prü­fung von Daten ist Python sta­tic­me­thod ideal.

class Validator:
    @staticmethod
    def isInteger(num):
        try:
            int(num)
            return True
        except ValueError:
            return False
    @staticmethod
    def isDecimal(num):
        try:
            float(num)
            return True
        except ValueError:
            return False
input = "123"
is_integer = Validator.isInteger(input)
print(f"Is '{input}' an integer? {is_integer}") # Output: Is '123' an integer? True
input = "3.14"
is_dec = Validator.isDecimal(input)
print(f"Is '{input}' a decimal number? {is_dec}") # Output: Is '3.14' a decimal number? True
python

Die Klasse Validator nutzt die sta­ti­schen Methoden isInteger() und isDecimal(). Diese prüfen, ob ein Wert eine Ganzzahl oder ein De­zi­mal­wert ist. Die Methode isInteger() versucht eine Um­wand­lung in (int(num)). Klappt das, kommt True zurück. Schlägt es fehl, wird die Ausnahme ValueError ab­ge­fan­gen und False aus­ge­ge­ben.

Analog dazu wandelt isDecimal() die Eingabe in eine De­zi­mal­zahl (float(num)) um. Erfolg liefert True, Miss­erfolg False. Danach va­li­die­ren wir mit den Methoden von Validator die Testwerte "123" und "3.14". In beiden Fällen ist das Ergebnis wahr.

Ma­ni­pu­la­ti­on von Strings

class StringManipulation:
    @staticmethod
    def reverseText(text):
        return text[::-1]
input_text = "Hello World!"
result = StringManipulation.reverseText(input_text)
print(f"Reversed text of '{input_text}': {result}") # Output: Reversed text of 'Hello World!': !dlroW olleH
python

Hier de­fi­nie­ren wir die Klasse StringManipulation mit der sta­ti­schen Methode reverseText(). Sie nimmt einen Text entgegen, nutzt die Slicing-Syntax [::-1], um den "Hello World!" um­zu­dre­hen, und gibt das Resultat aus.

Zum Hauptmenü