# Hoe Python staticmethod() te gebruiken Statische methoden kunnen rechtstreeks **via de klassenaam** worden aangeroepen zonder dat de klasse hoeft te worden geïnstantieerd. Deze eigenschap van Python `staticmethod` maakt een duidelijke scheiding mogelijk tussen klasselogica en instantiegegevens. ## Waarvoor wordt Python `staticmethod` gebruikt? Python `staticmethod` is zowel een functie als een decorator. Het wordt gebruikt om methoden aan te duiden die onafhankelijk van klasse-instanties werken. Decorators in Python zijn functies die het gedrag van andere methoden wijzigen door aanvullende functionaliteit toe te voegen vóór of na hun uitvoering, zonder de oorspronkelijke functiecode te wijzigen. In tegenstelling tot instantiemethoden **hebben** statische functies **geen impliciete parameter** zoals `self` **nodig**. Het gebruik van `staticmethod` in Python biedt een gerichte benadering voor het structureren van functies binnen klassen die geen toegang tot instantiegegevens vereisen. Omdat ze niet aan een instantie gebonden zijn, kunnen ze **de status van een object** niet **wijzigen**. Binnen klassen dienen ze als waardevolle hulpmiddelen voor het uitvoeren van veelvoorkomende taken of het bieden van globale functionaliteit. Ze kunnen bijvoorbeeld hulpprogramma’s, conversieroutines en algemene hulpfuncties bevatten die zonder instantiegegevens kunnen worden aangeroepen. ## 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 ingebouwde Python-functie die een methode van een klasse **statisch** maakt. De retourwaarde van Python `staticmethod()` is een statische methode voor de functie die als argument wordt doorgegeven. De syntaxis is: ```python 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 gedefinieerd **als argument** door te geven aan `staticmethod()`, kunnen we nu de aangepaste methode rechtstreeks via de klassenaam 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 klassedefinitie** geplaatst. De syntaxis is: ```python class Class: @staticmethod def staticmethodFunc(x, y): return x + y print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12 ``` Het `@staticmethod` -decoratorsignaal geeft aan de **interpreter** door dat de gedefinieerde functie als een statische methode moet worden behandeld. ## Python `staticmethod` codevoorbeelden Je kunt statische methoden voor verschillende taken gebruiken. Hieronder staan een paar praktische voorbeelden van hoe je statische methoden kunt gebruiken. ### Eenheden omrekenen Python `staticmethod` is erg handig voor het omrekenen van eenheden. ```python 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 converteren. Methode `hoursToMinutes()` converteert uren naar minuten, terwijl `minutesToHours()` minuten naar uren converteert. We kunnen de statische methoden aanroepen via de klassenaam zonder dat we een instantie van de klasse hoeven aan te maken. Ze zijn toegankelijk via `Converter.hoursToMinutes()` of `Converter.minutesToHours()`, waarbij `Converter` de klassenaam is. We geven het resultaat weer in een **f-string**, een Python-stringformaat dat uitdrukkingen aan elkaar koppelt. ### Hulpfuncties voor wiskundige berekeningen Je kunt ook Python’s staticmethod() gebruiken om hulpfuncties voor secundaire berekeningen te definiëren. ```python 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 codevoorbeeld toont de klasse `Calculator` met statische methoden voor het berekenen van het kwadraat en de vierkantswortel 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 klassenaam. We voegen de resultaten van `Calculator.square()` en `Calculator.sqroot()` samen in een f-string. ### Validatie van inzendingen Een ander gebruik van Python’s staticmethod is het valideren van invoer. ```python 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 controleren 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` geretourneerd. Anders krijgen we `False` als er een **uitzondering `ValueError` wordt opgevangen**, 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` geretourneerd, anders `False`. Vervolgens gebruiken we de `isInteger()` en `isDecimal()` statische methoden van de `Validator` klasse om de invoer `"123"` en `"3.14"` te controleren. De resultaten zijn waar voor beide functies. ### Manipulatie van strings In het onderstaande voorbeeld definië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. ```python 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 ``` This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-staticmethod/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-staticmethod/) for AI/LLM consumption.