Tutorial per sta­tic­me­thod in Python: sintassi e ap­pli­ca­zio­ne

È possibile ri­chia­ma­re i metodi statici di­ret­ta­men­te tramite il nome della classe senza dover creare un’istanza della classe stessa. La funzione sta­tic­me­thod in Python favorisce quindi una chiara se­pa­ra­zio­ne tra la logica della classe e i dati delle istanze.

A cosa serve sta­tic­me­thod in Python?

La funzione sta­tic­me­thod in Python è un de­co­ra­to­re con cui puoi con­tras­se­gna­re i metodi che fun­zio­na­no in­di­pen­den­te­men­te dalle istanze di classe. I de­co­ra­to­ri in Python sono funzioni che mo­di­fi­ca­no il com­por­ta­men­to di altri metodi ag­giun­gen­do ulteriori fun­zio­na­li­tà prima o dopo la loro ese­cu­zio­ne. Nel farlo, non in­fluen­za­no il codice vero e proprio della funzione. Al contrario dei metodi di istanza, le funzioni statiche non ri­chie­do­no parametri impliciti come self per le istanze.

L’utilizzo di sta­tic­me­thod in Python offre la pos­si­bi­li­tà di or­ga­niz­za­re 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 mo­di­fi­ca­re lo stato di un oggetto. Si tratta di utili strumenti all’interno della classe per svolgere compiti generici o fornire fun­zio­na­li­tà globali. Ad esempio, possono contenere programmi di utilità, routine di con­ver­sio­ne o funzioni au­si­lia­rie generali che possono essere ri­chia­ma­te senza dati delle istanze.

La sintassi di sta­tic­me­thod in Python

Python offre due pos­si­bi­li­tà per creare metodi statici. Puoi uti­liz­za­re la funzione staticmethod() oppure il de­co­ra­to­re @staticmethod.

staticmethod()

staticmethod() è una funzione integrata in Python che permette di rendere statico un metodo di una classe. Il valore re­sti­tui­to 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

As­se­gnan­do come argomento a staticmethod() la funzione staticmethodFunc() definita nella classe Class, possiamo ri­chia­ma­re il nostro metodo di­ret­ta­men­te tramite il nome della classe.

@staticmethod

Il de­co­ra­to­re @staticmethod è un metodo più breve e più comune per definire una funzione come statica. Il de­co­ra­to­re viene po­si­zio­na­to nella de­fi­ni­zio­ne 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 de­co­ra­to­re @staticmethod segnala all’in­ter­pre­te che la funzione definita deve essere gestita come metodo statico.

Esempi di codice per l’utilizzo di sta­tic­me­thod in Python

È possibile uti­liz­za­re i metodi statici per i compiti più svariati. Nelle parti seguenti ti mostriamo alcuni esempi pratici.

Con­ver­sio­ne di unità

La funzione sta­tic­me­thod in Python è molto utile per la con­ver­sio­ne 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 con­ver­ti­re ore e minuti. Il metodo hoursToMinutes() converte le ore in minuti, mentre minutesToHours() converte i minuti in ore.

Per ri­chia­ma­re i metodi statici uti­liz­zia­mo il nome della classe senza dover creare un’istanza della classe stessa. L’accesso avviene di­ret­ta­men­te tramite Converter.hoursToMinutes() o Converter.minutesToHours(), dove Converter è il nome della classe. Per l’emissione del risultato uti­liz­zia­mo una f-string, ossia un metodo di for­mat­ta­zio­ne delle stringhe in Python che collega le espres­sio­ni fra loro.

Funzioni au­si­lia­rie per calcoli ma­te­ma­ti­ci

È possibile uti­liz­za­re sta­tic­me­thod in Python anche per definire funzioni au­si­lia­rie 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 de­co­ra­to­re @staticmethod con­tras­se­gnia­mo square() e sqroot() come metodi statici. Senza creare un’istanza della classe, ri­chia­mia­mo i metodi per mezzo del nome della classe. Quindi con­ca­te­nia­mo i risultati di Calculator.square() e Calculator.sqroot() in una f string.

Va­li­da­zio­ne dei dati inseriti

Un’ulteriore pos­si­bi­li­tà d’uso di sta­tic­me­thod in Python è la va­li­da­zio­ne 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 con­trol­la­no se un certo dato è un numero intero o un numero decimale. La funzione sta­tic­me­thod in Python isInteger() accetta un dato e tenta di con­ver­tir­lo in un numero intero (int(num)). Se ci riesce, re­sti­tui­sce il risultato True. In caso contrario otteniamo il risultato False se viene rilevata un’eccezione ValueError, che si verifica quando la va­li­da­zio­ne non è possibile.

Uti­liz­zia­mo invece il metodo isDecimal() per con­ver­ti­re il dato in un numero decimale (float(num)). Se l’esito è positivo, il metodo re­sti­tui­sce True; in caso contrario, re­sti­tui­sce False. Suc­ces­si­va­men­te uti­liz­zia­mo i metodi statici isInteger() e isDecimal() della classe Validator per ve­ri­fi­ca­re i dati "123" e "3.14". I risultati sono veri per entrambe le funzioni.

Ma­ni­po­la­zio­ne 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 pre­ce­den­te 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 re­sti­tui­re il risultato.