Tutoriel Python Sta­tic­me­thod : syntaxe et uti­li­sa­tion

Les méthodes statiques peuvent être appelées di­rec­te­ment par le nom de la classe, sans qu’il soit né­ces­saire de créer une instance de la classe. Python staticmethod favorise une sé­pa­ra­tion claire entre la logique de la classe et les données de l’instance.

À quoi sert Python staticmethod ?

Python staticmethod est à la fois une fonction et un dé­co­ra­teur per­met­tant d’iden­ti­fier les méthodes qui fonc­tion­nent in­dé­pen­dam­ment des instances de classe. Les dé­co­ra­teurs en Python sont des fonctions qui modifient le com­por­te­ment d’autres méthodes en ajoutant des fonc­tion­na­li­tés sup­plé­men­taires avant ou après leur exécution. Ce faisant, elles n’in­fluen­cent pas le code de la fonction pro­pre­ment dite. Con­trai­re­ment aux méthodes d’instance, les fonctions statiques ne né­ces­si­tent pas de paramètre implicite comme self pour les instances.

L’uti­li­sa­tion de staticmethod en Python offre une pos­si­bi­lité ciblée d’organiser des fonctions au sein de classes qui n’ont pas besoin d’accéder à des données d’instance. Comme elles ne sont pas liées à une instance, elles ne peuvent pas modifier l’état d’un objet. Elles servent d’outils utiles au sein de la classe pour accomplir des tâches générales ou fournir des fonc­tion­na­li­tés globales. Par exemple, elles peuvent contenir des uti­li­taires, des routines de con­ver­sion ou des fonctions d’aide générales qui peuvent être appelées sans données d’instance.

Syntaxe de Python staticmethod

Il y a deux façons de créer des méthodes statiques dans Python. Vous pouvez utiliser soit la fonction staticmethod(), soit le dé­co­ra­teur @staticmethod.

staticmethod()

staticmethod() est une fonction Python intégrée qui permet de rendre statique une méthode d’une classe. La valeur de retour de Python staticmethod() est une méthode statique pour la fonction qui est passée en argument. La syntaxe se présente comme suit :

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

En passant la fonction staticmethodFunc() définie dans la classe Class en argument à staticmethod(), nous pouvons appeler notre propre méthode di­rec­te­ment via le nom de la classe.

@staticmethod

Le dé­co­ra­teur @staticmethod est une méthode plus courte et plus courante pour marquer une fonction comme statique. Le dé­co­ra­teur est placé au-dessus de la méthode dans la dé­fi­ni­tion de la classe. La syntaxe est la suivante :

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

Le dé­co­ra­teur @staticmethod signale à l’in­ter­prète que la fonction définie doit être traitée comme une méthode statique.

Exemples de code pour l’uti­li­sa­tion de Python sta­tic­me­thod

Vous pouvez utiliser les méthodes statiques pour de nom­breuses tâches. Découvrez ci-dessous quelques exemples pratiques.

Con­ver­sion d’unités

Python staticmethod est très utile pour convertir des unités.

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.

Dans cet exemple, la classe Converter possède deux méthodes statiques pour convertir les heures et les minutes. La méthode hoursToMinutes() convertit les heures en minutes, tandis que minutesToHours() convertit les minutes en heures.

Nous appelons les méthodes statiques via le nom de la classe, sans avoir à créer une instance de la classe. L’accès se fait di­rec­te­ment par Converter.hoursToMinutes() ou Converter.minutesToHours(), où Converter est le nom de la classe. Nous affichons le résultat dans une f-String, une méthode String Format en Python qui combine des ex­pres­sions entre elles.

Fonctions auxi­liaires pour les calculs ma­thé­ma­tiques

Vous pouvez aussi définir des fonctions auxi­liaires pour des calculs se­con­daires avec Python staticmethod.

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’exemple de code montre la classe Calculator avec des méthodes statiques pour le calcul du carré et de la racine carrée d’un nombre. Grâce au dé­co­ra­teur @staticmethod, nous marquons square() et sqroot() comme des méthodes statiques. Sans créer d’instance de la classe, nous appelons les méthodes via le nom de la classe. Nous con­ca­té­nons les résultats de Calculator.square() et Calculator.sqroot() dans une chaîne de ca­rac­tères f.

Va­li­da­tion des entrées

Une autre uti­li­sa­tion de Python staticmethod est la va­li­da­tion d’entrées.

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 comprend les deux méthodes statiques : isInteger() et isDecimal(). Ces fonctions vérifient si une entrée donnée est un nombre entier ou un nombre décimal. La méthode statique Python isInteger() prend une entrée et essaie de la convertir en un nombre entier (int(num)). Si elle y parvient, elle renvoie True. Sinon, nous obtenons False si une exception ValueError est in­ter­cep­tée, qui se produit lorsque la va­li­da­tion n’est pas possible.

Nous utilisons la méthode isDecimal() pour convertir l’entrée en un nombre décimal (float(num)). Si cette opération est réussie, True est renvoyé, et False si ce n’est pas le cas. Ensuite, nous vérifions les entrées "123" et "3.14" avec les méthodes statiques isInteger() et isDecimal() de la classe Validator. Les résultats sont vrais pour les deux fonctions.

Ma­ni­pu­la­tion de chaînes de ca­rac­tères

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

Dans l’exemple ci-dessus, nous dé­fi­nis­sons une classe StringManipulation avec une méthode statique reverseText(). Celle-ci prend un texte en paramètre et utilise la syntaxe de découpage [::-1] pour inverser le texte "Hello World!" et renvoyer le résultat.