Python staticmethod Tutorial: Syntax und Anwendung

Statische Methoden können Sie direkt über den Klassennamen aufrufen, ohne dass Sie eine Instanz der Klasse erstellen müssen. Python staticmethod fördert daher eine klare Trennung der Klassenlogik von Instanzdaten.

Wozu dient Python staticmethod?

Python staticmethod ist eine Funktion und ein Dekorator, um Methoden zu kennzeichnen, die unabhängig von Klasseninstanzen arbeiten. Dekoratoren in Python sind Funktionen, die das Verhalten anderer Methoden ändern, indem sie vor oder nach deren Ausführung zusätzliche Funktionalitäten hinzufügen. Dabei beeinflussen sie nicht den eigentlichen Funktionscode. Im Gegensatz zu Instanzmethoden erfordern statische Funktionen keinen impliziten Parameter wie self für Instanzen.

Der Einsatz von staticmethod in Python bietet eine gezielte Möglichkeit, Funktionen innerhalb von Klassen zu organisieren, die nicht auf Instanzdaten zugreifen müssen. Da sie nicht an eine Instanz gebunden sind, können sie den Zustand eines Objekts nicht modifizieren. Sie dienen als nützliche Werkzeuge innerhalb der Klasse, um allgemeine Aufgaben zu erfüllen oder globale Funktionalitäten bereitzustellen. Zum Beispiel können sie Dienstprogramme, Konvertierungsroutinen oder allgemeine Hilfsfunktionen beinhalten, die ohne Instanzdaten aufgerufen werden können.

So sieht die Syntax von Python staticmethod aus

Es gibt in Python zwei Möglichkeiten, statische Methoden zu erstellen. Sie können entweder die staticmethod()-Funktion oder den Dekorator @staticmethod benutzen.

staticmethod()

staticmethod() ist eine eingebaute Python-Funktion, mit der eine Methode einer Klasse statisch wird. Der Rückgabewert von Python staticmethod() ist eine statische Methode für die Funktion, die als Argument übergeben wird. Die Syntax sieht folgendermaßen aus:

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

Indem wir die in der Klasse Class definierte Funktion staticmethodFunc() als Argument an staticmethod() übergeben, können wir unsere eigene Methode direkt über den Namen der Klasse aufrufen.

@staticmethod

Der @staticmethod-Dekorator ist eine kürzere und üblichere Methode, um eine Funktion als statisch zu markieren. Der Dekorator wird über der Methode in der Klassendefinition platziert. Die Syntax lautet:

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

Der Dekorator @staticmethod signalisiert dem Interpreter, dass die definierte Funktion als statische Methode behandelt werden soll.

Codebeispiele für den Einsatz von Python staticmethod

Sie können statische Methoden für vielfältige Aufgaben anwenden. Im Folgenden stellen wir Ihnen ein paar praktische Beispiele vor.

Konvertieren von Einheiten

Python staticmethod ist sehr nützlich zum Konvertieren 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.

In diesem Beispiel besitzt die Klasse Converter zwei statische Methoden, um zwischen Stunden und Minuten umzurechnen. Die Methode hoursToMinutes() konvertiert Stunden in Minuten, während minutesToHours() Minuten in Stunden umwandelt.

Die statischen Methoden rufen wir über den Klassennamen auf, ohne dass eine Instanz der Klasse erstellt werden muss. Der Zugriff erfolgt direkt über Converter.hoursToMinutes() oder Converter.minutesToHours(), wobei Converter der Klassenname ist. Das Ergebnis geben wir in einem f-String aus, einer Python-String-Format-Methode, die Ausdrücke miteinander verknüpft.

Hilfsfunktionen für mathematische Berechnungen

Sie können mit Python staticmethod auch Hilfsfunktionen für Nebenrechnungen definieren.

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.

Das Codebeispiel zeigt die Klasse Calculator mit statischen Methoden zur Berechnung des Quadrats und der Quadratwurzel einer Zahl. Durch den @staticmethod-Dekorator kennzeichnen wir square() und sqroot() als statische Methoden. Ohne eine Instanz der Klasse zu erstellen, rufen wir die Methoden über den Klassennamen auf. Die Ergebnisse von Calculator.square() und Calculator.sqroot() verketten wir in einem f-String.

Validierung von Eingaben

Ein weiterer Verwendungszweck von Python staticmethod ist die Validierung von Eingaben.

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

Die Klasse Validator umfasst die beiden statischen Methoden: isInteger() und isDecimal(). Diese Funktionen überprüfen, ob eine gegebene Eingabe eine ganze Zahl oder eine Dezimalzahl ist. Die Python staticmethod isInteger() nimmt eine Eingabe entgegen und versucht, sie in eine Ganzzahl umzuwandeln (int(num)). Falls dies gelingt, wird True zurückgegeben. Andernfalls erhalten wir False, wenn eine Ausnahme ValueError abgefangen wird, die auftritt, wenn die Validierung nicht möglich ist.

Die Methode isDecimal() setzen wir ein, um die Eingabe in eine Dezimalzahl umzuwandeln (float(num)). Wenn dies erfolgreich ist, wird True zurückgegeben, ansonsten False. Anschließend prüfen wir mit den statischen Methoden isInteger() und isDecimal() der Klasse Validator die Eingaben "123" und "3.14". Die Ergebnisse sind für beide Funktionen wahr.

Manipulation 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

Im obigen Beispiel definieren wir eine Klasse StringManipulation mit einer statischen Methode reverseText(). Diese nimmt einen Text als Parameter entgegen und verwendet die Slicing-Syntax [::-1], um den Text "Hello World!" umzukehren und das Ergebnis zurückzugeben.