# Kaip naudoti Python staticmethod()

Statiniai metodai gali būti iškviečiami tiesiogiai **per klasės pavadinimą**, nereikia kurti klasės instancės. Ši Python staticmethod savybė palengvina aiškų klasės logikos atskyrimą nuo instancės duomenų.

## Kam naudojamas Python `staticmethod`?

Python `staticmethod` yra ir funkcija, ir dekoratorius. Jis naudojamas metodams, kurie veikia nepriklausomai nuo klasės instancų, žymėti. Dekoratoriai Python kalboje yra funkcijos, kurios keičia kitų metodų elgesį, prieš arba po jų vykdymo pridedant papildomą funkcionalumą, nekeičiant originalaus funkcijos kodo. Skirtingai nuo instancinių metodų, statinės funkcijos **nereikalauja numanomo parametro**, pvz., `self`.

`staticmethod` naudojimas Python kalboje siūlo tikslingą požiūrį į funkcijų struktūrizavimą klasėse, kurioms nereikia prieigos prie instancinių duomenų. Kadangi jos nėra susietos su instancija, jos negali **keisti objekto būsenos**. Klasėse jos yra vertingos priemonės bendroms užduotims atlikti ar globalioms funkcijoms teikti. Pavyzdžiui, jos gali talpinti pagalbines programas, konvertavimo procedūras ir bendras pagalbines funkcijas, kurias galima iškviesti be instancinių duomenų.

## Kokia yra Python `staticmethod` sintaksė?

Python kalboje yra du būdai sukurti statinius metodus. Galite naudoti `staticmethod()` funkciją arba `@staticmethod` dekoratorių.

### `staticmethod()`

`staticmethod()` yra įdiegta Python funkcija, kuri klasės metodą paverčia **statiniu**. Python `staticmethod()` grąžinamoji reikšmė yra statinis metodas funkcijai, kuri perduodama kaip argumentas. Sintaksė yra tokia:

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

Perduodami staticmethodFunc() funkciją, apibrėžtą Class klasėje, **kaip argumentą** staticmethod(), dabar galime tiesiogiai iškviesti pasirinktinį metodą per klasės pavadinimą.

### `@staticmethod`

`@staticmethod` dekoratorius yra trumpesnis ir labiau paplitęs būdas pažymėti funkciją kaip statinę. Dekoratorius yra įrašomas virš metodo **klasės apibrėžime**. Sintaksė yra tokia:

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

@staticmethod dekoratorius signalizuoja **interpretatoriui**, kad apibrėžta funkcija turėtų būti traktuojama kaip statinis metodas.

## Python `staticmethod` kodo pavyzdžiai

Statiniai metodai gali būti naudojami įvairioms užduotims atlikti. Toliau pateikiami keli praktiniai pavyzdžiai, kaip naudoti statinius metodus.

### Vienetų konvertavimas

Python `staticmethod` yra labai naudingas vienetų konvertavimui.

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

Šiame pavyzdyje klasė Converter turi du statinius metodus, skirtus valandų ir minučių konvertavimui. Metodas hoursToMinutes() konvertuoja valandas į minutes, o minutesToHours() – minutes į valandas.

Statiniai metodai gali būti iškviečiami per klasės pavadinimą, nesukuriant klasės egzemplioriaus. Jie pasiekiami per `Converter.hoursToMinutes()` arba `Converter.minutesToHours()`, kur `Converter` yra klasės pavadinimas. Rezultatas išvedamas **f-string** formatu, Python stygos formatu, kuris jungia išraiškas.

### Pagalbinės funkcijos matematiniams skaičiavimams

Taip pat galite naudoti Python statinį metodą staticmethod(), kad apibrėžtumėte pagalbines funkcijas antriniams skaičiavimams.

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

Kodo pavyzdyje pateikta Calculator klasė su statiniais metodais, skirtais skaičiaus kvadratui ir kvadratinei šakniai apskaičiuoti. Naudojame @staticmethod dekoratorių, kad square() ir sqroot() pažymėtume kaip statinius metodus. Nesukurdami klasės egzemplioriaus, metodus iškvietame per klasės pavadinimą. Calculator.square() ir Calculator.sqroot() rezultatus sujungiame f-eilutėje.

### Įrašų patvirtinimas

Kitas Python statinio metodo naudojimas yra įvesties patvirtinimas.

```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ė apima du statinius metodus: isInteger() ir isDecimal(). Šios funkcijos patikrina, ar pateiktas įvesties duomenys yra sveikasis skaičius ar dešimtainis skaičius. Python statinis metodas isInteger() paima įvesties duomenis ir bando juos konvertuoti į sveikąjį skaičių (int(num)). Jei tai pavyksta, grąžinamas True. Kitaip, jei **aptinkama išimtis ValueError**, kuri atsiranda, kai patvirtinimas neįmanomas, gauname False.

Naudojame `isDecimal()` metodą, kad įvestį konvertuotume į dešimtainį skaičių `(float(num))`. Jei pavyksta, grąžinamas `True`, kitaip – `False`. Tada naudojame `isInteger()` ir `isDecimal()` statinius `Validator` klasės metodus, kad patikrintume įvestis `"123"` ir `"3.14"`. Abiejų funkcijų rezultatai yra teisingi.

### Stygų manipuliavimas

Toliau pateiktame pavyzdyje apibrėžiame klasę `StringManipulation` su statiniu metodu `reverseText()`. Jis priima tekstą kaip parametrą ir naudoja skaidymo sintaksę `[::-1]`, kad apverstų tekstą `"Hello World!"` ir grąžintų rezultatą.

```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/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-staticmethod/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-staticmethod/) for AI/LLM consumption.