# Kako uporabljati Python staticmethod()

Statične metode se lahko pokličejo neposredno **prek imena razreda**, brez da bi bilo treba razred instanciirati. Ta značilnost Python `staticmethod` omogoča jasno ločitev logike razreda od podatkov instance.

## Za kaj se uporablja Python `staticmethod`?

Python `staticmethod` je tako funkcija kot dekorator. Uporablja se za označevanje metod, ki delujejo neodvisno od primerov razredov. Dekoratorji v Pythonu so funkcije, ki spreminjajo delovanje drugih metod z dodajanjem dodatnih funkcionalnosti pred ali po njihovem izvajanju, ne da bi spreminjali izvirni kod funkcije. Za razliko od metod primerov, statične funkcije **ne potrebujejo implicitnega parametra**, kot je `self`.

Uporaba `staticmethod` v Pythonu ponuja osredotočen pristop k strukturiranju funkcij znotraj razredov, ki ne zahtevajo dostopa do podatkov o primerkih. Ker niso vezani na primerke, ne morejo **spreminjati stanja objekta**. Znotraj razredov služijo kot dragocena orodja za izvajanje pogostih nalog ali ponujanje globalne funkcionalnosti. Na primer, lahko vsebujejo pomožne programe, rutine za pretvorbo in splošne pomožne funkcije, ki jih je mogoče poklicati brez podatkov o primerkih.

## Kakšna je sintaksa Python `staticmethod`?

V Pythonu obstajata dva načina za ustvarjanje statičnih metod. Uporabite lahko funkcijo `staticmethod()` ali dekorator `@staticmethod`.

### `staticmethod()`

`staticmethod()` je vgrajena funkcija Python, ki naredi metodo razreda **statično**. Vrnjena vrednost Python `staticmethod()` je statična metoda za funkcijo, ki je prenesena kot argument. Sintaksa je:

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

S predajo funkcije `staticmethodFunc()`, definirane v razredu `Class`, **kot argumenta** `staticmethod()`, lahko zdaj pokličemo prilagojeno metodo neposredno prek imena razreda.

### `@staticmethod`

Dekorator `@staticmethod` je krajša in bolj pogosta metoda za označevanje funkcije kot statične. Dekorator se postavi nad metodo **v definiciji razreda**. Sintaksa je:

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

Dekorator `@staticmethod` **interpreterju** signalizira, da je treba definirano funkcijo obravnavati kot statično metodo.

## Primeri kode v Python `staticmethod`

Statične metode lahko uporabljate za različne naloge. Spodaj je nekaj praktičnih primerov, kako uporabljati statične metode.

### Pretvarjanje enot

Python `staticmethod` je zelo uporaben za pretvarjanje enot.

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

V tem primeru ima razred `Converter` dve statični metodi za pretvorbo med urami in minutami. Metoda `hoursToMinutes()` pretvarja ure v minute, medtem ko `minutesToHours()` pretvarja minute v ure.

Statične metode lahko pokličemo prek imena razreda, ne da bi morali ustvariti instanco razreda. Dostopamo do njih prek `Converter.hoursToMinutes()` ali `Converter.minutesToHours()`, kjer je `Converter` ime razreda. Rezultat izpišemo v **f-nizu**, formatu niza v Pythonu, ki povezuje izraze.

### Pomožne funkcije za matematične izračune

Za opredelitev pomožnih funkcij za sekundarne izračune lahko uporabite tudi Pythonovo staticmethod().

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

Primer kode prikazuje razred `Calculator` s statičnimi metodami za izračun kvadrata in kvadratnega korena števila. Z dekoratorjem `@staticmethod` označimo `square()` in `sqroot()` kot statični metodi. Brez ustvarjanja instance razreda pokličemo metode prek imena razreda. Rezultate `Calculator.square()` in `Calculator.sqroot()` združimo v f-nizu.

### Preverjanje vnosov

Druga uporaba statične metode Python je preverjanje veljavnosti vnosov.

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

Razred `Validator` obsega dve statični metodi: `isInteger()` in `isDecimal()`. Ti funkciji preverjata, ali je dani vnos celo število ali decimalno število. Statična metoda Python `isInteger()` sprejme vnos in poskuša ga pretvoriti v celo število `(int(num))`. Če je uspešna, se vrne `True`. V nasprotnem primeru dobimo `False`, če **je ujet izjemni primer `ValueError`**, kar se zgodi, ko preverjanje ni mogoče.

Uporabimo metodo `isDecimal()`, da pretvorimo vhodno vrednost v decimalno število `(float(num))`. Če je pretvorba uspešna, se vrne `True`, sicer pa `False`. Nato uporabimo statični metodi `isInteger()` in `isDecimal()` razreda `Validator`, da preverimo vhodni vrednosti `"123"` in `"3.14"`. Rezultati sta pravilni za obe funkciji.

### Manipulacija nizov

V spodnjem primeru definiramo razred `StringManipulation` s statično metodo `reverseText()`. Ta sprejme besedilo kot parameter in uporabi sintakso za razrez `[::-1]`, da obrne besedilo `"Hello World!"` in vrne 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/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/python-staticmethod/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/python-staticmethod/) for AI/LLM consumption.