# Sådan bruges Python staticmethod()

Statiske metoder kan kaldes direkte **via klassens navn** uden at skulle instansiere klassen. Denne egenskab ved Python `staticmethod` muliggør en klar adskillelse af klasselogik og instansdata.

## Hvad bruges Python `staticmethod` til?

Python `staticmethod` er både en funktion og en dekorator. Den bruges til at udpege metoder, der fungerer uafhængigt af klasseinstanser. Dekoratorer i Python er funktioner, der ændrer andre metoders adfærd ved at tilføje supplerende funktionalitet før eller efter deres udførelse uden at ændre den oprindelige funktionskode. I modsætning til instansmetoder **kræver** statiske funktioner **ikke en implicit parameter** som f.eks. `self`.

Brugen af `staticmethod` i Python giver en fokuseret tilgang til strukturering af funktioner inden for klasser, der ikke kræver adgang til instansdata. Da de ikke er bundet til en instans, kan de ikke **ændre et objekts tilstand**. Inden for klasser fungerer de som værdifulde værktøjer til udførelse af almindelige opgaver eller til at tilbyde global funktionalitet. De kan f.eks. indeholde hjælpeprogrammer, konverteringsrutiner og generelle hjælpefunktioner, der kan påkaldes uden instansdata.

## Hvad er syntaksen i Python `staticmethod`?

Der er to måder at oprette statiske metoder i Python. Du kan bruge funktionen `staticmethod()` eller dekoratoren `@staticmethod`.

### `staticmethod()`

`staticmethod()` er en indbygget Python-funktion, der gør en metode i en klasse **statisk**. Returværdien af Python `staticmethod()` er en statisk metode for den funktion, der overføres som et argument. Syntaksen er:

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

Ved at videregive den `staticmethodFunc()` funktion, der er defineret i `Class` klassen, **som et argument** til `staticmethod()`, kan vi nu kalde den brugerdefinerede metode direkte via klassens navn.

### `@staticmethod`

`@staticmethod` er en kortere og mere almindelig metode til at markere en funktion som statisk. Dekoratoren placeres over metoden **i klassedefinitionen**. Syntaksen er:

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

`@staticmethod` signalerer til **fortolkeren**, at den definerede funktion skal behandles som en statisk metode.

## Python `staticmethod` kodeeksempler

Du kan bruge statiske metoder til en række forskellige opgaver. Nedenfor er nogle praktiske eksempler på, hvordan du kan bruge statiske metoder.

### Konvertering af enheder

Python `staticmethod` er meget nyttigt til at konvertere enheder.

```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.
```

I dette eksempel har klasse `Converter` to statiske metoder til at konvertere mellem timer og minutter. Metoden `hoursToMinutes()` konverterer timer til minutter, mens `minutesToHours()` konverterer minutter til timer.

Vi kan kalde de statiske metoder via klassens navn uden at skulle oprette en instans af klassen. De tilgås via `Converter.hoursToMinutes()` eller `Converter.minutesToHours()`, hvor `Converter` er klassens navn. Vi udskriver resultatet i en **f-streng**, et Python-strengformat, der forbinder udtryk.

### Hjælpefunktioner til matematiske beregninger

Du kan også bruge Pythons staticmethod() til at definere hjælpefunktioner til sekundære beregninger.

```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.
```

Kodeeksemplet viser klassen `Calculator` med statiske metoder til beregning af kvadratet og kvadratroden af et tal. Vi bruger dekoratoren `@staticmethod` til at markere `square()` og `sqroot()` som statiske metoder. Uden at oprette en instans af klassen kalder vi metoderne via klassens navn. Vi sammenkæder resultaterne af `Calculator.square()` og `Calculator.sqroot()` i en f-streng.

### Validering af indtastninger

En anden anvendelse af Pythons staticmethod er validering af input.

```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
```

Klasse `Validator` består af de to statiske metoder: `isInteger()` og `isDecimal()`. Disse funktioner kontrollerer, om en given indtastning er et heltal eller et decimaltal. Den statiske metode `isInteger()` i Python tager en indtastning og forsøger at konvertere den til et heltal `(int(num))`. Hvis det lykkes, returneres `True`. Ellers får vi `False`, hvis **der opstår** en **undtagelse `ValueError`**, hvilket sker, når validering ikke er mulig.

Vi bruger metoden `isDecimal()` til at konvertere inputtet til et decimaltal `(float(num))`. Hvis det lykkes, returneres `True`, ellers `False`. Derefter bruger vi de statiske metoder `isInteger()` og `isDecimal()` i klassen `Validator` til at kontrollere inputtene `"123"` og `"3.14"`. Resultaterne er sande for begge funktioner.

### Manipulation af strenge

I eksemplet nedenfor definerer vi klassen `StringManipulation` med den statiske metode `reverseText()`. Denne tager en tekst som parameter og bruger slicing-syntaksen `[::-1]` til at vende teksten `"Hello World!"` og returnere resultatet.

```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/da-dk/digitalguide/websteder/webudvikling/python-staticmethod/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-staticmethod/) for AI/LLM consumption.