Réponse.

En Python, il existe trois types principaux de méthodes : les méthodes d'instance, les méthodes de classe et les méthodes statiques. Historiquement, Python ne supportait que les méthodes d'instance (avec le premier paramètre self). Avec le temps, il est devenu nécessaire d'avoir des types de méthodes supplémentaires : accessibles via la classe sans lien avec un objet et ayant accès à la classe elle-même.

Problème : il est souvent nécessaire de créer des méthodes qui ne dépendent pas de l'état d'une instance d'objet (par exemple, des méthodes de fabrique) ou qui n'ont pas besoin de contexte de classe mais qui s'intègrent logiquement dans la structure de la classe.

Solution : utiliser les décorateurs @classmethod et @staticmethod.

Une méthode d'instance ordinaire (self) travaille avec un objet spécifique, peut lire et modifier son état.
Une méthode de classe (cls) reçoit en premier argument la classe elle-même (et non l'instance), utile pour les fabriques et les fonctions d'assistance.
Une méthode statique ne reçoit ni self ni cls, c'est juste une fonction à l'intérieur de la classe, qu'il est pratique de grouper ainsi logiquement.

Exemple de code :

class Example:
    def instance_method(self):
        return f'instance: {self}'

    @classmethod
    def class_method(cls):
        return f'class: {cls}'

    @staticmethod
    def static_method():
        return 'static'

Caractéristiques clés :

Les méthodes ordinaires travaillent toujours avec self (instance de la classe).
Les méthodes de classe sont nécessaires pour travailler avec la classe sans créer d'instance.
Les méthodes statiques sont utiles pour des fonctions « utilitaires » de la classe, qui n'ont pas besoin de contexte de classe ou d'objet.

Questions pièges.

Un méthode statique peut-elle accéder aux attributs de la classe et de l'instance ?

Non, la méthode statique n'obtient pas de référence à la classe ni à l'objet.

class A:
    x = 10
    @staticmethod
    def f():
        # print(self.x)  # Erreur
        pass

Les méthodes de classe peuvent-elles être redéfinies dans les descendants ?

Oui, lors de l'appel de classmethod à travers un descendant, le premier argument sera toujours la classe réelle, et non le parent.

class Base:
    @classmethod
    def name(cls):
        return cls.__name__

class Child(Base):
    pass

Child.name()  # "Child"

Pourquoi ne pas utiliser self pour les méthodes de classe ?

Parce que la méthode de classe n'est pas liée à un objet spécifique, mais à la classe dans son ensemble ; self n'est pas accessible sans créer une instance.

Erreurs classiques et anti-patterns

Confondre staticmethod et classmethod.
Tenter d'accéder à self à partir de classmethod (ou vice versa).
Utiliser staticmethod là où un accès à la classe est nécessaire.

Exemple de la vie réelle

Cas négatif

Une méthode de fabrique définie comme staticmethod, mais essayant de créer une instance de classe via self, ce qui entraîne des erreurs ou des duplications de code.

Avantages :

Il semblait plus simple de déclarer une méthode statique.

Inconvénients :

Impossible de créer correctement des instances de classes dérivées — on obtient toujours la classe de base.

Cas positif

La fabrique est déclarée via classmethod, utilisant la classe réelle (cls) pour créer une instance. Les descendants sont correctement créés via cette fabrique.