# Hvordan bruke Python staticmethod()

Statiske metoder kan påkalles direkte **via klassens navn** uten at det er nødvendig å instansiere klassen. Denne egenskapen i Python `staticmethod` muliggjør en tydelig separasjon mellom klasselogikk og instansdata.

## Hva brukes Python `staticmethod` til?

Python `staticmethod` er både en funksjon og en dekorator. Den brukes til å betegne metoder som fungerer uavhengig av klasseinstanser. Dekoratorer i Python er funksjoner som endrer oppførselen til andre metoder ved å legge til tilleggsfunksjonalitet før eller etter utførelsen, uten å endre den opprinnelige funksjonskoden. I motsetning til instansmetoder **krever** statiske funksjoner **ikke en implisitt parameter** som `self`.

Bruken av `staticmethod` i Python gir en fokusert tilnærming til strukturering av funksjoner innenfor klasser som ikke krever tilgang til instansdata. Siden de ikke er bundet til en instans, kan de ikke **endre tilstanden til et objekt**. Innenfor klasser fungerer de som verdifulle verktøy for å utføre vanlige oppgaver eller tilby global funksjonalitet. De kan for eksempel inneholde verktøyprogrammer, konverteringsrutiner og generelle hjelpefunksjoner som kan påkalles uten instansdata.

## Hva er syntaksen til Python `staticmethod`?

Det er to måter å lage statiske metoder på i Python. Du kan bruke funksjonen `staticmethod()` eller dekoratoren `@staticmethod`.

### `staticmethod()`

`staticmethod()` er en innebygd Python-funksjon som gjør en metode i en klasse **statisk**. Returverdien av Python `staticmethod()` er en statisk metode for funksjonen som sendes 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 å overføre funksjonen `staticmethodFunc()` definert i klassen `Class` **som et argument** til `staticmethod()`, kan vi nå kalle den tilpassede metoden direkte via klassens navn.

### `@staticmethod`

Dekoratoren `@staticmethod` er en kortere og mer vanlig metode for å merke en funksjon som statisk. Dekoratoren plasseres over metoden **i klassedefinisjonen**. Syntaksen er:

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

Dekoratoren `@staticmethod` signaliserer til **tolken** at den definerte funksjonen skal behandles som en statisk metode.

## Python `staticmethod` kodeeksempler

Du kan bruke statiske metoder til en rekke oppgaver. Nedenfor finner du noen praktiske eksempler på hvordan du kan bruke statiske metoder.

### Konvertering av enheter

Python `staticmethod` er veldig nyttig for å konvertere enheter.

```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 eksemplet har klasse `Converter` to statiske metoder for å konvertere mellom timer og minutter. Metoden `hoursToMinutes()` konverterer timer til minutter, mens `minutesToHours()` konverterer minutter til timer.

Vi kan kalle opp de statiske metodene via klassens navn uten å måtte opprette en instans av klassen. De nås via `Converter.hoursToMinutes()` eller `Converter.minutesToHours()`, hvor `Converter` er klassens navn. Vi skriver ut resultatet i en **f-streng**, et Python-strengformat som kobler sammen uttrykk.

### Hjelpefunksjoner for matematiske beregninger

Du kan også bruke Pythons staticmethod() til å definere hjelpefunksjoner for 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 for å beregne kvadratet og kvadratroten av et tall. Vi bruker dekoratoren `@staticmethod` til å merke `square()` og `sqroot()` som statiske metoder. Uten å opprette en instans av klassen, kaller vi metodene via klassens navn. Vi sammenføyer resultatene av `Calculator.square()` og `Calculator.sqroot()` i en f-streng.

### Validering av oppføringer

En annen bruk av Pythons staticmethod er validering av inndata.

```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 av to statiske metoder: `isInteger()` og `isDecimal()`. Disse funksjonene sjekker om en gitt inndata er et heltall eller et desimaltall. Den statiske metoden `isInteger()` i Python tar en inndata og prøver å konvertere den til et heltall `(int(num))`. Hvis dette lykkes, returneres `True`. Ellers får vi `False` hvis en **unntak `ValueError` blir fanget opp**, noe som skjer når validering ikke er mulig.

Vi bruker metoden `isDecimal()` til å konvertere inndataene til et desimaltall `(float(num))`. Hvis dette lykkes, returneres `True`, ellers `False`. Deretter bruker vi de statiske metodene `isInteger()` og `isDecimal()` i klassen `Validator` til å sjekke inndataene `"123"` og `"3.14"`. Resultatene er sanne for begge funksjonene.

### Manipulering av strenger

I eksemplet nedenfor definerer vi klassen `StringManipulation` med den statiske metoden `reverseText()`. Denne tar en tekst som parameter og bruker slicing-syntaksen `[::-1]` til å reversere 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/nb-no/digitalguide/nettsteder/webutvikling/python-staticmethod/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-staticmethod/) for AI/LLM consumption.