Méthodes de classe (@classmethod) : méthodes liées à la classe

Qu'est-ce qu'une méthode de classe ? Définition et caractéristiques

En Python, une méthode de classe est une méthode qui est liée à la classe elle-même, et non à une instance spécifique de la classe (un objet).

Contrairement aux méthodes d'instance (les méthodes ordinaires), qui reçoivent l'objet lui-même comme premier argument (`self`), les méthodes de classe reçoivent la *classe* elle-même comme premier argument (généralement nommé `cls`, par convention).

Les méthodes de classe sont définies en utilisant le décorateur `@classmethod` avant la définition de la méthode.

Syntaxe :

class MaClasse:
    @classmethod
    def ma_methode_de_classe(cls, autres_arguments):
        # Corps de la méthode de classe
        # ...

• `@classmethod` : Le décorateur qui indique que la méthode est une méthode de classe.
• `cls` : Le premier argument, qui représente la classe elle-même (par convention, on utilise `cls`, mais vous pourriez techniquement utiliser un autre nom).
• `autres_arguments` : Les autres arguments de la méthode (optionnels).

Le paramètre cls : la classe elle-même

Le paramètre `cls` (abréviation courante pour "class") est l'équivalent de `self` pour les méthodes de classe. Il représente la classe sur laquelle la méthode est appelée, et non une instance particulière de cette classe.

A l'intérieur de la méthode de classe, vous pouvez utiliser `cls` pour :

• Accéder aux attributs de classe.
• Appeler d'autres méthodes de classe.
• Créer de nouvelles instances de la classe (voir l'exemple des fabriques alternatives plus loin).

Exemple (simple) :

class MaClasse:
    variable_de_classe = 10

    @classmethod
    def afficher_variable_de_classe(cls):
        print("Variable de classe :", cls.variable_de_classe)

MaClasse.afficher_variable_de_classe()  # Appel via la classe : affiche "Variable de classe : 10"

obj = MaClasse()
obj.afficher_variable_de_classe()      # Appel via une instance : affiche aussi "Variable de classe : 10"

Dans cet exemple, `afficher_variable_de_classe` est une méthode de classe. Elle prend `cls` comme premier argument et accède à la variable de classe `variable_de_classe` en utilisant `cls.variable_de_classe`.

Notez que vous pouvez appeler une méthode de classe soit via la classe elle-même (`MaClasse.afficher_variable_de_classe()`), soit via une instance de la classe (`obj.afficher_variable_de_classe()`). Dans les deux cas, `cls` fera référence à la classe `MaClasse`.

Cas d'utilisation : fabriques alternatives (constructeurs alternatifs)

Un cas d'utilisation courant des méthodes de classe est de créer des "fabriques alternatives" (ou "constructeurs alternatifs"). Il s'agit de méthodes de classe qui créent et retournent une nouvelle instance de la classe, mais avec une initialisation différente de celle du constructeur standard (`__init__`).

Exemple :

import datetime

class Personne:
    def __init__(self, nom, annee_naissance):
        self.nom = nom
        self.annee_naissance = annee_naissance

    @classmethod
    def depuis_age(cls, nom, age):
        """Crée une Personne à partir de son nom et de son âge."""
        annee_courante = datetime.date.today().year
        annee_naissance = annee_courante - age
        return cls(nom, annee_naissance)  # Crée et retourne une instance de Personne

# Utilisation du constructeur standard
p1 = Personne("Alice", 1990)

# Utilisation de la fabrique alternative
p2 = Personne.depuis_age("Bob", 30)  # Crée une Personne avec l'année de naissance calculée

print(p2.nom, p2.annee_naissance)

Dans cet exemple :

• `__init__` est le constructeur standard. Il prend le nom et l'année de naissance.
• `depuis_age` est une méthode de classe (une fabrique alternative). Elle prend le nom et l'âge, calcule l'année de naissance, et *retourne une nouvelle instance de `Personne`* en utilisant `cls(nom, annee_naissance)`.

Notez l'utilisation de `cls(...)` dans `depuis_age`. Cela permet de créer une instance de la classe courante (ici, `Personne`), même si la méthode est appelée depuis une sous-classe.

Méthodes de classes et héritage

Lorsqu'une méthode de classe est appelée sur une sous-classe, le paramètre `cls` fait référence à la sous-classe, et non à la classe mère où la méthode de classe est définie.

Exemple :

class Mere:
  @classmethod
  def qui_suis_je(cls):
    print(cls.__name__)
    
class Fille(Mere):
  pass
  
Mere.qui_suis_je() # Affiche Mere
Fille.qui_suis_je() # Affiche Fille

C'est ce comportement qui rend les méthodes de classe utiles pour les fabriques alternatives, car elles peuvent créer des instances de la classe sur laquelle elles sont appelées, même si c'est une sous-classe.

Méthodes de classe vs. méthodes d'instance vs. méthodes statiques

Voici un tableau récapitulatif des différences entre les trois types de méthodes :