Hoe Python sta­tic­me­thod() te gebruiken

Statische methoden kunnen recht­streeks via de klas­se­naam worden aan­ge­roe­pen zonder dat de klasse hoeft te worden ge­ïn­stan­ti­eerd. Deze ei­gen­schap van Python staticmethod maakt een dui­de­lij­ke scheiding mogelijk tussen klas­se­logi­ca en in­stan­tie­ge­ge­vens.

Waarvoor wordt Python staticmethod gebruikt?

Python staticmethod is zowel een functie als een decorator. Het wordt gebruikt om methoden aan te duiden die on­af­han­ke­lijk van klasse-in­stan­ties werken. De­co­ra­tors in Python zijn functies die het gedrag van andere methoden wijzigen door aan­vul­len­de func­ti­o­na­li­teit toe te voegen vóór of na hun uit­voe­ring, zonder de oor­spron­ke­lij­ke func­tie­co­de te wijzigen. In te­gen­stel­ling tot in­stan­tie­me­tho­den hebben statische functies geen im­pli­cie­te parameter zoals self nodig.

Het gebruik van staticmethod in Python biedt een gerichte be­na­de­ring voor het struc­tu­re­ren van functies binnen klassen die geen toegang tot in­stan­tie­ge­ge­vens vereisen. Omdat ze niet aan een instantie gebonden zijn, kunnen ze de status van een object niet wijzigen. Binnen klassen dienen ze als waar­de­vol­le hulp­mid­de­len voor het uitvoeren van veel­voor­ko­men­de taken of het bieden van globale func­ti­o­na­li­teit. Ze kunnen bij­voor­beeld hulp­pro­gram­ma’s, con­ver­sie­rou­ti­nes en algemene hulp­func­ties bevatten die zonder in­stan­tie­ge­ge­vens kunnen worden aan­ge­roe­pen.

Wat is de syntaxis van Python staticmethod?

Er zijn twee manieren om statische methoden in Python te maken. Je kunt de functie staticmethod() of de decorator @staticmethod gebruiken.

staticmethod()

staticmethod() is een in­ge­bouw­de Python-functie die een methode van een klasse statisch maakt. De re­tour­waar­de van Python staticmethod() is een statische methode voor de functie die als argument wordt door­ge­ge­ven. De syntaxis is:

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

Door de staticmethodFunc() functie die in de Class klasse is ge­de­fi­ni­eerd als argument door te geven aan staticmethod(), kunnen we nu de aan­ge­pas­te methode recht­streeks via de klas­se­naam aanroepen.

@staticmethod

De @staticmethod decorator is een kortere en meer gangbare methode om een functie als statisch te markeren. De decorator wordt boven de methode in de klas­se­de­fi­ni­tie geplaatst. De syntaxis is:

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

Het @staticmethod -de­co­ra­tor­sig­naal geeft aan de in­ter­pre­ter door dat de ge­de­fi­ni­eer­de functie als een statische methode moet worden behandeld.

Python staticmethod co­de­voor­beel­den

Je kunt statische methoden voor ver­schil­len­de taken gebruiken. Hieronder staan een paar prak­ti­sche voor­beel­den van hoe je statische methoden kunt gebruiken.

Eenheden omrekenen

Python staticmethod is erg handig voor het omrekenen van eenheden.

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 dit voorbeeld heeft klasse Converter twee statische methoden om tussen uren en minuten te con­ver­te­ren. Methode hoursToMinutes() con­ver­teert uren naar minuten, terwijl minutesToHours() minuten naar uren con­ver­teert.

We kunnen de statische methoden aanroepen via de klas­se­naam zonder dat we een instantie van de klasse hoeven aan te maken. Ze zijn toe­gan­ke­lijk via Converter.hoursToMinutes() of Converter.minutesToHours(), waarbij Converter de klas­se­naam is. We geven het resultaat weer in een f-string, een Python-string­for­maat dat uit­druk­kin­gen aan elkaar koppelt.

Hulp­func­ties voor wis­kun­di­ge be­re­ke­nin­gen

Je kunt ook Python’s sta­tic­me­thod() gebruiken om hulp­func­ties voor se­cun­dai­re be­re­ke­nin­gen te de­fi­ni­ë­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.

Het co­de­voor­beeld toont de klasse Calculator met statische methoden voor het berekenen van het kwadraat en de vier­kants­wor­tel van een getal. We gebruiken de decorator @staticmethod om square() en sqroot() als statische methoden te markeren. Zonder een instantie van de klasse te maken, roepen we de methoden aan via de klas­se­naam. We voegen de re­sul­ta­ten van Calculator.square() en Calculator.sqroot() samen in een f-string.

Validatie van in­zen­din­gen

Een ander gebruik van Python’s sta­tic­me­thod is het valideren van invoer.

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

De klasse Validator bestaat uit twee statische methoden: isInteger() en isDecimal(). Deze functies con­tro­le­ren of een bepaalde invoer een geheel getal of een decimaal getal is. De Python statische methode isInteger() neemt een invoer en probeert deze om te zetten in een geheel getal (int(num)). Als dit lukt, wordt True ge­re­tour­neerd. Anders krijgen we False als er een uit­zon­de­ring ValueError wordt op­ge­van­gen, wat gebeurt wanneer validatie niet mogelijk is.

We gebruiken de isDecimal() methode om de invoer om te zetten in een decimaal getal (float(num)). Als dit lukt, wordt True ge­re­tour­neerd, anders False. Ver­vol­gens gebruiken we de isInteger() en isDecimal() statische methoden van de Validator klasse om de invoer "123" en "3.14" te con­tro­le­ren. De re­sul­ta­ten zijn waar voor beide functies.

Ma­ni­pu­la­tie van strings

In het on­der­staan­de voorbeeld de­fi­ni­ë­ren we de klasse StringManipulation met de statische methode reverseText(). Deze neemt een tekst als parameter en gebruikt de slicing-syntaxis [::-1] om de tekst "Hello World!" om te keren en het resultaat terug te geven.

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