# Pythonin staticmethod()-funktion käyttö

Staattiset menetelmät voidaan kutsua suoraan **luokan nimen kautta** ilman, että luokkaa tarvitsee instansoida. Tämä Python `staticmethod` ominaisuus helpottaa luokan logiikan ja instanssitietojen selkeää erottamista toisistaan.

## Mihin Python `staticmethod` käytetään?

Python `staticmethod` on sekä funktio että koriste. Sitä käytetään määrittämään menetelmiä, jotka toimivat riippumatta luokkien instansseista. Koristeet Pythonissa ovat funktioita, jotka muokkaavat muiden menetelmien käyttäytymistä lisäämällä lisätoimintoja ennen tai jälkeen niiden suorittamisen, muuttamatta alkuperäistä funktiokoodia. Toisin kuin instanssimenetelmät, staattiset funktiot **eivät vaadi implisiittistä parametria**, kuten `self`.

Pythonissa `staticmethod` käyttö tarjoaa kohdennetun lähestymistavan luokkien sisällä olevien funktioiden jäsentämiseen, jotka eivät vaadi pääsyä instanssitietoihin. Koska ne eivät ole sidottuja instanssiin, ne eivät **voi muuttaa objektin tilaa**. Luokkien sisällä ne toimivat arvokkaina työkaluina yleisten tehtävien suorittamiseen tai globaalien toimintojen tarjoamiseen. Ne voivat esimerkiksi sisältää apuohjelmia, muunnosrutiineja ja yleisiä apufunktioita, joita voidaan kutsua ilman instanssitietoja.

## Mikä on Python `staticmethod`:n syntaksi?

Pythonissa on kaksi tapaa luoda staattisia metodeja. Voit käyttää `staticmethod()` -funktiota tai `@staticmethod`.

### `staticmethod()`

`staticmethod()` on sisäänrakennettu Python-funktio, joka tekee luokan metodista **staattisen**. Pythonin palautusarvo `staticmethod()` on staattinen metodi funktiolle, joka välitetään argumenttina. Syntaksi on:

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

Syöttämällä `Class` määritellyn `staticmethodFunc()` **argumenttina** `staticmethod()`ään, voimme nyt kutsua mukautetun menetelmän suoraan luokan nimen kautta.

### `@staticmethod`

`@staticmethod` on lyhyempi ja yleisempi tapa merkitä funktio staattiseksi. Dekoratori sijoitetaan **luokan määritelmässä** metodin yläpuolelle. Syntaksi on:

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

`@staticmethod` ilmoittaa **tulkille**, että määriteltyä funktiota tulisi käsitellä staattisena menetelmänä.

## Python `staticmethod` -koodiesimerkit

Staattisia menetelmiä voidaan käyttää monenlaisiin tehtäviin. Alla on muutamia käytännön esimerkkejä staattisten menetelmien käytöstä.

### Yksiköiden muuntaminen

Python `staticmethod` on erittäin hyödyllinen yksiköiden muuntamisessa.

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

Tässä esimerkissä luokalla `Converter` on kaksi staattista menetelmää tuntien ja minuuttien muuntamiseksi. Menetelmä `hoursToMinutes()` muuntaa tunnit minuuteiksi, kun taas `minutesToHours()` muuntaa minuutit tunneiksi.

Voimme kutsua staattisia metodeja luokan nimen kautta ilman, että meidän tarvitsee luoda luokan instanssia. Niihin pääsee käsiksi `Converter.hoursToMinutes()` tai `Converter.minutesToHours()` kautta, jossa `Converter` on luokan nimi. Tulostamme tuloksen **f-merkkijonona**, joka on Python-merkkijonomuoto, joka linkittää lausekkeita.

### Matemaattisten laskelmien aputoiminnot

Voit myös käyttää Pythonin staticmethod()-funktiota apufunktioiden määrittelemiseen toissijaisia laskelmia varten.

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

Koodiesimerkki esittelee `Calculator`, jossa on staattiset menetelmät luvun neliön ja neliöjuuren laskemiseksi. Käytämme `@staticmethod` merkitsemään `square()` ja `sqroot()` staattisiksi menetelmiksi. Luomatta luokan instanssia kutsumme menetelmiä luokan nimen kautta. Yhdistämme `Calculator.square()` ja `Calculator.sqroot()` tulokset f-merkkijonossa.

### Tietojen vahvistaminen

Pythonin staticmethod-menetelmän toinen käyttötarkoitus on syötteiden validointi.

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

Luokka `Validator` sisältää kaksi staattista menetelmää: `isInteger()` ja `isDecimal()`. Nämä funktiot tarkistavat, onko annettu syöte kokonaisluku vai desimaaliluku. Pythonin staattinen menetelmä `isInteger()` ottaa syötteen ja yrittää muuntaa sen kokonaisluvuksi `(int(num))`. Jos muuntaminen onnistuu, palautetaan `True`. Muussa tapauksessa saadaan `False`, jos **poikkeus `ValueError` havaitaan**, mikä tapahtuu, kun validointi ei ole mahdollista.

Käytämme `isDecimal()` muuntaaksemme syötteen desimaaliluvuksi `(float(num))`. Jos muunnos onnistuu, palautetaan `True`, muuten `False`. Sitten käytämme `isInteger()` ja `isDecimal()` -luokan staattisia menetelmiä `Validator` tarkistaaksemme syötteet `"123"` ja `"3.14"`. Tulokset ovat totta molemmille funktioille.

### Merkkijonojen manipulointi

Alla olevassa esimerkissä määritellään luokka `StringManipulation` staattisella menetelmällä `reverseText()`. Se ottaa parametriksi tekstin ja käyttää leikkaussyntaxia `[::-1]` tekstin kääntämiseen `"Hello World!"` ja tuloksen palauttamiseen.

```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/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/python-staticmethod/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/python-staticmethod/) for AI/LLM consumption.