# Kuidas kasutada Python staticmethod()

Staatilisi meetodeid saab kutsuda otse **klassi nime kaudu**, ilma et oleks vaja klassi instantsi luua. See Python `staticmethod` omadus hõlbustab klassi loogika ja instantsi andmete selget eraldamist.

## Milleks kasutatakse Python `staticmethod`?

Python `staticmethod` on nii funktsioon kui ka dekorator. Seda kasutatakse klassi instantsidest sõltumatult toimivate meetodite määramiseks. Dekoratorid Pythonis on funktsioonid, mis muudavad teiste meetodite käitumist, lisades enne või pärast nende täitmist täiendavaid funktsioone, ilma algset funktsioonikoodi muutmata. Erinevalt instantsimeetoditest **ei vaja** staatilised funktsioonid **implitsiitset parameetrit**, nagu näiteks `self`.

Pythonis `staticmethod` kasutamine pakub keskendunud lähenemisviisi klasside sees funktsioonide struktureerimisele, mis ei vaja juurdepääsu instantsi andmetele. Kuna need ei ole seotud instantsiga, ei saa nad **muuta objekti seisundit**. Klasside sees on need väärtuslikud vahendid tavaliste ülesannete täitmiseks või globaalse funktsionaalsuse pakkumiseks. Näiteks võivad need sisaldada utiliidiprogramme, teisendamisrutiine ja üldisi abifunktsioone, mida saab käivitada ilma instantsi andmeteta.

## Mis on Python `staticmethod` süntaks?

Pythonis on staatiliste meetodite loomiseks kaks võimalust. Saate kasutada funktsiooni `staticmethod()` või dekoratorit `@staticmethod`.

### `staticmethod()`

`staticmethod()` on sisseehitatud Python-funktsioon, mis muudab klassi meetodi **staatiliseks**. Python `staticmethod()` tagastab staatilise meetodi funktsioonile, mis on edastatud argumendina. Süntaks on järgmine:

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

Edastades `Class` klassis määratletud `staticmethodFunc()` funktsiooni **argumendina** `staticmethod()`, saame nüüd kutsuda kohandatud meetodit otse klassi nime kaudu.

### `@staticmethod`

`@staticmethod` dekorator on lühem ja levinum meetod funktsiooni staatiliseks märkimiseks. Dekorator paigutatakse **klassi määratluses** meetodi kohale. Süntaks on järgmine:

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

`@staticmethod` dekorator annab **tõlkijale** märku, et määratletud funktsiooni tuleks käsitleda staatilise meetodina.

## Python `staticmethod` koodinäited

Staatilisi meetodeid saab kasutada mitmesuguste ülesannete jaoks. Allpool on toodud mõned praktilised näited staatiliste meetodite kasutamise kohta.

### Ühikute teisendamine

Python `staticmethod` on väga kasulik ühikute teisendamiseks.

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

Selles näites on klassil `Converter` kaks staatilist meetodit tundide ja minutite vaheliseks teisendamiseks. Meetod `hoursToMinutes()` teisendab tunnid minutiteks, `minutesToHours()` aga minutid tundideks.

Me saame staatilisi meetodeid kutsuda klassi nime kaudu, ilma et peaksime looma klassi instantsi. Neile pääseb ligi `Converter.hoursToMinutes()` või `Converter.minutesToHours()` kaudu, kus `Converter` on klassi nimi. Me väljastame tulemuse **f-stringis**, mis on Pythonis kasutatav stringi formaat, mis ühendab väljendeid.

### Matemaatiliste arvutuste abifunktsioonid

Teiseks arvutusteks abifunktsioonide määratlemiseks võite kasutada ka Pythoni staticmethod()-funktsiooni.

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

Koodinäide demonstreerib klassi `Calculator` staatiliste meetoditega numbri ruudu ja ruutjuure arvutamiseks. Kasutame dekoratorit `@staticmethod`, et märkida `square()` ja `sqroot()` staatilisteks meetoditeks. Ilma klassi instantsi loomata kutsume meetodeid klassi nime kaudu. Ühendame tulemused `Calculator.square()` ja `Calculator.sqroot()` f-stringis.

### Sissekannete kinnitamine

Pythoni staticmethodi teine kasutusala on sisendite valideerimine.

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

Klass `Validator` koosneb kahest staatilisest meetodist: `isInteger()` ja `isDecimal()`. Need funktsioonid kontrollivad, kas antud sisend on täisarv või kümnendnumber. Python staatiline meetod `isInteger()` võtab sisendi ja üritab selle teisendada täisarvuks `(int(num))`. Kui see õnnestub, tagastatakse `True`. Muidu saame `False`, kui **tabatakse erand `ValueError`**, mis juhtub siis, kui valideerimine ei ole võimalik.

Kasutame `isDecimal()` meetodit, et teisendada sisend kümnendmurruks `(float(num))`. Eduka tulemuse korral tagastatakse `True`, muidu `False`. Seejärel kasutame `isInteger()` ja `isDecimal()` klassi staatilisi meetodeid `Validator`, et kontrollida sisendeid `"123"` ja `"3.14"`. Mõlema funktsiooni tulemused on tõesed.

### Stringide manipuleerimine

Allpool toodud näites määratleme klassi `StringManipulation` staatilise meetodiga `reverseText()`. See võtab parameetrina teksti ja kasutab lõikamissüntaksit `[::-1]`, et tekst `"Hello World!"` ümber pöörata ja tulemus tagasi anda.

```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/et-ee/digitalguide/veebisaidid/veebiarendus/python-staticmethod/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/python-staticmethod/) for AI/LLM consumption.