# Tutorial per staticmethod in Python: sintassi e applicazione

È possibile **richiamare** i metodi statici direttamente **tramite il nome della classe** senza dover creare un’istanza della classe stessa. La funzione staticmethod in Python favorisce quindi una chiara separazione tra la logica della classe e i dati delle istanze.

## A cosa serve staticmethod in Python?

La funzione staticmethod in Python è un decoratore con cui puoi contrassegnare i metodi che funzionano indipendentemente dalle istanze di classe. I decoratori in Python sono funzioni che modificano il comportamento di altri metodi aggiungendo ulteriori funzionalità prima o dopo la loro esecuzione. Nel farlo, non influenzano il codice vero e proprio della funzione. Al contrario dei metodi di istanza, le funzioni statiche **non richiedono parametri impliciti** come `self` per le istanze.

L’utilizzo di staticmethod in Python offre la possibilità di organizzare in modo mirato le funzioni all’interno di classi che non devono accedere ai dati delle istanze. Poiché non sono legati a un’istanza, **non possono modificare lo stato di un oggetto**. Si tratta di utili strumenti all’interno della classe per svolgere compiti generici o fornire funzionalità globali. Ad esempio, possono contenere programmi di utilità, routine di conversione o funzioni ausiliarie generali che possono essere richiamate senza dati delle istanze.

## La sintassi di staticmethod in Python

Python offre due possibilità per creare metodi statici. Puoi utilizzare la funzione `staticmethod()` oppure il decoratore `@staticmethod`.

### `staticmethod()`

`staticmethod()` è una funzione integrata in Python che permette di rendere **statico** un metodo di una classe. Il valore restituito da `staticmethod()` in Python è un metodo statico per la funzione assegnata come argomento. La sintassi si presenta così:

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

Assegnando **come argomento** a `staticmethod()` la funzione `staticmethodFunc()` definita nella classe `Class`, possiamo richiamare il nostro metodo direttamente tramite il nome della classe.

### `@staticmethod`

Il decoratore `@staticmethod` è un metodo più breve e più comune per definire una funzione come statica. Il decoratore viene **posizionato nella definizione della classe** sopra il metodo. La sintassi è la seguente:

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

Il decoratore `@staticmethod` segnala all’**interprete** che la funzione definita deve essere gestita come metodo statico.

## Esempi di codice per l’utilizzo di staticmethod in Python

È possibile utilizzare i metodi statici per i compiti più svariati. Nelle parti seguenti ti mostriamo alcuni esempi pratici.

### Conversione di unità

La funzione staticmethod in Python è molto utile per la conversione di unità.

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

In questo esempio, la classe `Converter` presenta due metodi statici per convertire ore e minuti. Il metodo `hoursToMinutes()` converte le ore in minuti, mentre `minutesToHours()` converte i minuti in ore.

Per richiamare i metodi statici utilizziamo il nome della classe senza dover creare un’istanza della classe stessa. L’accesso avviene direttamente tramite `Converter.hoursToMinutes()` o `Converter.minutesToHours()`, dove `Converter` è il nome della classe. Per l’emissione del risultato utilizziamo una **f-string**, ossia un metodo di [formattazione delle stringhe in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/formattazione-delle-stringhe-in-python/) che collega le espressioni fra loro.

### Funzioni ausiliarie per calcoli matematici

È possibile utilizzare staticmethod in Python anche per definire funzioni ausiliarie per calcoli accessori.

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

L’esempio mostra la classe `Calculator` con metodi statici per il calcolo del quadrato e della radice quadrata di un numero. Con il decoratore `@staticmethod` contrassegniamo `square()` e `sqroot()` come metodi statici. Senza creare un’istanza della classe, richiamiamo i metodi per mezzo del nome della classe. Quindi concateniamo i risultati di `Calculator.square()` e `Calculator.sqroot()` in una f string.

### Validazione dei dati inseriti

Un’ulteriore possibilità d’uso di staticmethod in Python è la validazione dei dati inseriti.

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

La classe `Validator` comprende i due metodi statici `isInteger()` e `isDecimal()`. Queste funzioni controllano se un certo dato è un numero intero o un numero decimale. La funzione staticmethod in Python `isInteger()` accetta un dato e tenta di convertirlo in un numero intero `(int(num))`. Se ci riesce, restituisce il risultato `True`. In caso contrario otteniamo il risultato `False` se viene **rilevata un’eccezione `ValueError`**, che si verifica quando la validazione non è possibile.

Utilizziamo invece il metodo `isDecimal()` per convertire il dato in un numero decimale `(float(num))`. Se l’esito è positivo, il metodo restituisce `True`; in caso contrario, restituisce `False`. Successivamente utilizziamo i metodi statici `isInteger()` e `isDecimal()` della classe `Validator` per verificare i dati `"123"` e `"3.14"`. I risultati sono veri per entrambe le funzioni.

### Manipolazione di stringhe

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

Nell’esempio precedente abbiamo definito una classe `StringManipulation` con il metodo statico `reverseText()`. Il metodo accetta un testo come parametro e utilizza la sintassi di slicing `[::-1]` per scrivere al contrario il testo `"Hello World!"` e restituire il risultato.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/funzione-staticmethod-in-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/funzione-staticmethod-in-python/) for AI/LLM consumption.