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ì:

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:

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

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 che collega le espressioni fra loro.

Funzioni ausiliarie per calcoli matematici

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

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.

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

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.