Réponse.

Python prend en charge trois types de méthodes dans les définitions de classes : les méthodes d'instance, les méthodes de classe et les méthodes statiques. Elles diffèrent par la manière dont elles sont appelées et par leur accès aux données de la classe et de l'instance.

Historique :

À l'origine, les méthodes d'instance (celles avec "self") étaient le seul type de comportement, on supposait que les méthodes appelaient toujours un comportement ou modifiaient/lisaient les données d'un objet spécifique. Plus tard, Python a introduit les méthodes de classe (avec "cls"), fournissant un comportement pour la classe dans son ensemble (par exemple, des constructeurs alternatifs), et des méthodes statiques, semblables à des fonctions normales, mais liées à la classe.

Problématique :

Parfois, une fonctionnalité générale est nécessaire pour toutes les instances (méthodes statiques). Parfois, une opération doit être accessible "pour toute la classe" (par exemple, la création d'une instance). Cela étant dit, si le type de méthode est mal défini — cela peut provoquer des bugs (par exemple, essayer accidentellement de modifier la classe via une méthode d'instance, ou vice versa).

Solution :

Méthodes d'instance (méthodes normales, paramètre self) : Accès aux données et au comportement d'un objet spécifique.
Méthodes de classe (avec le décorateur @classmethod, paramètre cls) : Accès à l'état de la classe, mais pas à l'état de l'objet. Utilisées pour créer des constructeurs alternatifs et pour des opérations qui doivent toucher à la classe, pas à l'instance.
Méthodes statiques (avec le décorateur @staticmethod) : N'ont accès ni à self ni à cls; fonctions normales, placées dans l'espace de noms de la classe.

Exemple de code :

class MyClass:
    def instance_method(self):
        return f"Instance : {self}"

    @classmethod
    def class_method(cls):
        return f"Classe : {cls}"

    @staticmethod
    def static_method():
        return "Ceci est une méthode statique"

obj = MyClass()
print(obj.instance_method())  # Instance : <MyClass object...>
print(MyClass.class_method()) # Classe : <class 'MyClass'>
print(MyClass.static_method())# Ceci est une méthode statique

Caractéristiques clés :

Les méthodes d'instance ont toujours en premier argument self, peuvent travailler avec les attributs de l'objet
Les méthodes de classe ont toujours en premier argument cls, opèrent sur la classe ou sur l'instance
Les méthodes statiques n'ont pas d'arguments implicites en premier

Questions piégées.

Peut-on appeler une méthode d'instance directement à partir de la classe ?

Oui, mais il est nécessaire de transmettre explicitement l'objet :

MyClass.instance_method(obj)

ce qui est rarement approprié.

Comportement des méthodes statiques lors de l'héritage : peuvent-elles être redéfinies ?

Oui, on peut déclarer une staticmethod dans une classe enfant avec le même nom, et c'est celle-ci qui sera appelée lorsque appelée à partir de l'héritier.

À quoi servent les méthodes de classe si l'on peut toujours utiliser des méthodes statiques avec cls comme argument ?

cls n'est pas simplement le premier argument : dans classmethod, Python substitue lui-même la classe correspondante comme cls, même si l'appel provient d'un héritier. Cela permet de créer une hiérarchie alternative de constructeurs sans lien strict avec le parent.

Exemple :

class Base:
    @classmethod
    def make(cls):
        return cls()
class Child(Base):
    pass
Child.make() # renverra Child, pas Base

Erreurs fréquentes et anti-patterns

Utilisation de méthodes statiques pour des opérations dépendant de l'état interne de l'objet ou de la classe
Ordre incorrect des arguments (manque de self ou cls)
Mélange de la logique de différents types de méthodes dans une seule classe

Exemple de la vie réelle

Cas négatif

Dans le projet, des méthodes normales étaient utilisées pour créer des instances alternatives (par exemple, create_from_json). En raison de cela, lors de l'héritage, la méthode retournait toujours un objet de la classe de base, et non celui de l'héritier.

Avantages :

Mise en œuvre simple

Inconvénients :

Limitation dans le support de l'héritage, liaison stricte avec le parent

Cas positif

Des usines classmethod ont été mises en œuvre, qui retournent des instances de la classe actuelle (cls()), même lorsqu'elles sont appelées depuis un héritier.