Tutoriel Python Staticmethod : syntaxe et utilisation

Les méthodes statiques peuvent être appelées directement par le nom de la classe, sans qu’il soit nécessaire de créer une instance de la classe. Python staticmethod favorise une séparation 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écorateur permettant d’identifier les méthodes qui fonctionnent indépendamment des instances de classe. Les décorateurs en Python sont des fonctions qui modifient le comportement d’autres méthodes en ajoutant des fonctionnalités supplémentaires avant ou après leur exécution. Ce faisant, elles n’influencent pas le code de la fonction proprement dite. Contrairement aux méthodes d’instance, les fonctions statiques ne nécessitent pas de paramètre implicite comme self pour les instances.

L’utilisation de staticmethod en Python offre une possibilité 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 fonctionnalités globales. Par exemple, elles peuvent contenir des utilitaires, des routines de conversion 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écorateur @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 directement via le nom de la classe.

@staticmethod

Le décorateur @staticmethod est une méthode plus courte et plus courante pour marquer une fonction comme statique. Le décorateur est placé au-dessus de la méthode dans la définition 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écorateur @staticmethod signale à l’interprète que la fonction définie doit être traitée comme une méthode statique.

Exemples de code pour l’utilisation de Python staticmethod

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

Conversion 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 directement 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 expressions entre elles.

Fonctions auxiliaires pour les calculs mathématiques

Vous pouvez aussi définir des fonctions auxiliaires pour des calculs secondaires 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écorateur @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 concaténons les résultats de Calculator.square() et Calculator.sqroot() dans une chaîne de caractères f.

Validation des entrées

Une autre utilisation de Python staticmethod est la validation 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 interceptée, qui se produit lorsque la validation 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.

Manipulation de chaînes de caractè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éfinissons 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.