# Kā lietot Python staticmethod()

Statiskās metodes var izsaukt tieši, **izmantojot klases nosaukumu**, bez nepieciešamības instanciēt klasi. Šī Python `staticmethod` īpašība atvieglo klases loģikas skaidru nošķiršanu no instancēšanas datiem.

## Kādam nolūkam tiek izmantots Python `staticmethod`?

Python `staticmethod` ir gan funkcija, gan dekorators. To izmanto, lai apzīmētu metodes, kas darbojas neatkarīgi no klases instancēm. Dekoratori Python ir funkcijas, kas maina citu metožu darbību, pievienojot papildu funkcionalitāti pirms vai pēc to izpildes, nemainot sākotnējo funkcijas kodu. Atšķirībā no instancēm metodēm, statiskajām funkcijām **nav nepieciešams implicīts parametrs**, piemēram, `self`.

`staticmethod` izmantošana Python piedāvā koncentrētu pieeju funkciju strukturēšanai klasēs, kurām nav nepieciešama piekļuve instancēm. Tā kā tās nav saistītas ar instanci, tās nevar **mainīt objekta stāvokli**. Klasēs tās kalpo kā vērtīgi rīki kopīgu uzdevumu izpildei vai globālu funkciju piedāvāšanai. Piemēram, tās var ietvert utilītprogrammas, konvertēšanas rutīnas un vispārīgas palīgfunkcijas, kuras var izsaukt bez instancēm.

## Kāda ir Python `staticmethod` sintakse?

Python valodā ir divi veidi, kā izveidot statiskas metodes. Jūs varat izmantot `staticmethod()` funkciju vai `@staticmethod` dekoratoru.

### `staticmethod()`

`staticmethod()` ir iebūvēta Python funkcija, kas padara klases metodi **statisku**. Python `staticmethod()` atgriešanas vērtība ir statiska metode funkcijai, kas tiek nodota kā arguments. Sintakse ir šāda:

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

Pārsūtot `staticmethodFunc()` funkciju, kas definēta `Class` klasē **kā arguments** `staticmethod()`, tagad varam izsaukt pielāgoto metodi tieši caur klases nosaukumu.

### `@staticmethod`

Dekorators `@staticmethod` ir īsāka un izplatītāka metode, lai atzīmētu funkciju kā statisku. Dekorators tiek novietots virs metodes **klases definīcijā**. Sintakse ir šāda:

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

`@staticmethod` dekorators norāda **interpretatoram**, ka definētā funkcija jāuzskata par statisku metodi.

## Python `staticmethod` koda piemēri

Statiskās metodes var izmantot dažādiem uzdevumiem. Turpmāk ir sniegti daži praktiski piemēri, kā izmantot statiskās metodes.

### Vienību konvertēšana

Python `staticmethod` ir ļoti noderīgs vienību konvertēšanai.

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

Šajā piemērā klasē `Converter` ir divas statiskas metodes, kas veic konvertēšanu starp stundām un minūtēm. Metode `hoursToMinutes()` konvertē stundas minūtēs, bet `minutesToHours()` konvertē minūtes stundās.

Mēs varam izsaukt statiskās metodes, izmantojot klases nosaukumu, bez nepieciešamības izveidot klases instanci. Tām piekļūst, izmantojot `Converter.hoursToMinutes()` vai `Converter.minutesToHours()`, kur `Converter` ir klases nosaukums. Mēs izvadām rezultātu **f-string**, Python string formātā, kas saista izteiksmes.

### Palīgfunkcijas matemātiskajiem aprēķiniem

Jūs varat arī izmantot Python statisko metodi staticmethod(), lai definētu palīgfunkcijas sekundāriem aprēķiniem.

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

Koda piemērā parādīta `Calculator` klase ar statiskām metodēm skaitļa kvadrāta un kvadrātsaknes aprēķināšanai. Mēs izmantojam `@staticmethod` dekoratoru, lai atzīmētu `square()` un `sqroot()` kā statiskas metodes. Neizveidojot klases instanci, mēs izsaucam metodes, izmantojot klases nosaukumu. Mēs savienojam `Calculator.square()` un `Calculator.sqroot()` rezultātus f-stringā.

### Ierakstu apstiprināšana

Vēl viens Python statiskās metodes pielietojums ir ievades validēšana.

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

`Validator` klasē ir divas statiskas metodes: `isInteger()` un `isDecimal()`. Šīs funkcijas pārbauda, vai dotā ievade ir vesels skaitlis vai decimālskaitlis. Python statiskā metode `isInteger()` pieņem ievadi un mēģina to pārvērst veselos skaitļos `(int(num))`. Ja tas izdodas, tiek atgriezts `True`. Pretējā gadījumā mēs saņemam `False`, ja **tiek noķerta izņēmuma situācija `ValueError`**, kas notiek, ja validācija nav iespējama.

Mēs izmantojam `isDecimal()` metodi, lai pārvērstu ievadi decimālskaitlī `(float(num))`. Ja tas izdodas, tiek atgriezts `True`, citādi `False`. Tad mēs izmantojam `isInteger()` un `isDecimal()` statiskās metodes no `Validator` klases, lai pārbaudītu ievades `"123"` un `"3.14"`. Rezultāti ir patiesi abām funkcijām.

### Stīgu manipulācija

Zemāk redzamajā piemērā mēs definējam klasi `StringManipulation` ar statisko metodi `reverseText()`. Tā kā parametru izmanto tekstu un izmanto sadalīšanas sintaksi `[::-1]`, lai apgrieztu tekstu `"Hello World!"` un atgrieztu rezultātu.

```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/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/python-staticmethod/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/python-staticmethod/) for AI/LLM consumption.