Python sta­tic­me­thod Tutorial: Syntax und Anwendung

Statische Methoden können Sie direkt über den Klas­sen­na­men aufrufen, ohne dass Sie eine Instanz der Klasse erstellen müssen. Python sta­tic­me­thod fördert daher eine klare Trennung der Klas­sen­lo­gik von In­stanz­da­ten.

Wozu dient Python sta­tic­me­thod?

Python sta­tic­me­thod ist eine Funktion und ein Dekorator, um Methoden zu kenn­zeich­nen, die un­ab­hän­gig von Klas­sen­in­stan­zen arbeiten. De­ko­ra­to­ren in Python sind Funk­tio­nen, die das Verhalten anderer Methoden ändern, indem sie vor oder nach deren Aus­füh­rung zu­sätz­li­che Funk­tio­na­li­tä­ten hin­zu­fü­gen. Dabei be­ein­flus­sen sie nicht den ei­gent­li­chen Funk­ti­ons­code. Im Gegensatz zu In­stanz­me­tho­den erfordern statische Funk­tio­nen keinen im­pli­zi­ten Parameter wie self für Instanzen.

Der Einsatz von sta­tic­me­thod in Python bietet eine gezielte Mög­lich­keit, Funk­tio­nen innerhalb von Klassen zu or­ga­ni­sie­ren, die nicht auf In­stanz­da­ten zugreifen müssen. Da sie nicht an eine Instanz gebunden sind, können sie den Zustand eines Objekts nicht mo­di­fi­zie­ren. Sie dienen als nützliche Werkzeuge innerhalb der Klasse, um all­ge­mei­ne Aufgaben zu erfüllen oder globale Funk­tio­na­li­tä­ten be­reit­zu­stel­len. Zum Beispiel können sie Dienst­pro­gram­me, Kon­ver­tie­rungs­rou­ti­nen oder all­ge­mei­ne Hilfs­funk­tio­nen be­inhal­ten, die ohne In­stanz­da­ten auf­ge­ru­fen werden können.

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

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

staticmethod()

staticmethod() ist eine ein­ge­bau­te Python-Funktion, mit der eine Methode einer Klasse statisch wird. Der Rück­ga­be­wert von Python staticmethod() ist eine statische Methode für die Funktion, die als Argument übergeben wird. Die Syntax sieht fol­gen­der­ma­ß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 de­fi­nier­te 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 Klas­sen­de­fi­ni­ti­on 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 si­gna­li­siert dem In­ter­pre­ter, dass die de­fi­nier­te Funktion als statische Methode behandelt werden soll.

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

Sie können statische Methoden für viel­fäl­ti­ge Aufgaben anwenden. Im Folgenden stellen wir Ihnen ein paar prak­ti­sche Beispiele vor.

Kon­ver­tie­ren von Einheiten

Python sta­tic­me­thod ist sehr nützlich zum Kon­ver­tie­ren 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 um­zu­rech­nen. Die Methode hoursToMinutes() kon­ver­tiert Stunden in Minuten, während minutesToHours() Minuten in Stunden umwandelt.

Die sta­ti­schen Methoden rufen wir über den Klas­sen­na­men auf, ohne dass eine Instanz der Klasse erstellt werden muss. Der Zugriff erfolgt direkt über Converter.hoursToMinutes() oder Converter.minutesToHours(), wobei Converter der Klas­sen­na­me ist. Das Ergebnis geben wir in einem f-String aus, einer Python-String-Format-Methode, die Ausdrücke mit­ein­an­der verknüpft.

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

Sie können mit Python sta­tic­me­thod auch Hilfs­funk­tio­nen für Ne­ben­rech­nun­gen de­fi­nie­ren.

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 Code­bei­spiel zeigt die Klasse Calculator mit sta­ti­schen Methoden zur Be­rech­nung des Quadrats und der Qua­drat­wur­zel einer Zahl. Durch den @staticmethod-Dekorator kenn­zeich­nen wir square() und sqroot() als statische Methoden. Ohne eine Instanz der Klasse zu erstellen, rufen wir die Methoden über den Klas­sen­na­men auf. Die Er­geb­nis­se von Calculator.square() und Calculator.sqroot() verketten wir in einem f-String.

Va­li­die­rung von Eingaben

Ein weiterer Ver­wen­dungs­zweck von Python sta­tic­me­thod ist die Va­li­die­rung 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 sta­ti­schen Methoden: isInteger() und isDecimal(). Diese Funk­tio­nen über­prü­fen, ob eine gegebene Eingabe eine ganze Zahl oder eine De­zi­mal­zahl ist. Die Python sta­tic­me­thod isInteger() nimmt eine Eingabe entgegen und versucht, sie in eine Ganzzahl um­zu­wan­deln (int(num)). Falls dies gelingt, wird True zu­rück­ge­ge­ben. An­dern­falls erhalten wir False, wenn eine Ausnahme ValueError ab­ge­fan­gen wird, die auftritt, wenn die Va­li­die­rung nicht möglich ist.

Die Methode isDecimal() setzen wir ein, um die Eingabe in eine De­zi­mal­zahl um­zu­wan­deln (float(num)). Wenn dies er­folg­reich ist, wird True zu­rück­ge­ge­ben, ansonsten False. An­schlie­ßend prüfen wir mit den sta­ti­schen Methoden isInteger() und isDecimal() der Klasse Validator die Eingaben "123" und "3.14". Die Er­geb­nis­se sind für beide Funk­tio­nen 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

Im obigen Beispiel de­fi­nie­ren wir eine Klasse StringManipulation mit einer sta­ti­schen Methode reverseText(). Diese nimmt einen Text als Parameter entgegen und verwendet die Slicing-Syntax [::-1], um den Text "Hello World!" um­zu­keh­ren und das Ergebnis zu­rück­zu­ge­ben.