Les méthodes de classes et statiques en python

Les méthodes de classes sont différentes des méthodes d’instances en ce qu’elles prennent comme premier argument la classe elle-même. De plus, une méthode de classe est liée à la classe, mais pas à l’objet de cette classe.

Nous avons déjà vu la méthode d’instance qui prend en paramètre self , qui pointe vers l’instance de l’objet qui a appelé la méthode.

Cependant, une méthode de classe est une méthode qui a accès à l’état de la classe. Pour la créer, on utilise le décorateur @classmethod.

Si vous ne savez pas ce qu’un décorateur, voici un article qui vous expliquera pas à pas ce concept.

@classmethod 
def fonction(cls, param1, param2,.... , paramN): 
  # la fonction

Avant de continuer, nous allons aborder une autre forme de méthodes. Ce sont les méthodes statiques, qui ne prennent pas d’instance d’objet (self) ou de classe (cls), ce qui signifie qu’elles ne peuvent pas accéder à leurs états. Mais elles sont liées à la classe.
Le décorateur @staticmethod est utilisé pour créer une méthode statique.

Les méthodes d’instances, de classes et statiques

Nous allons prendre un exemple simple pour vous permettre de faire la différence entre ces trois formes de méthodes.

class Calcul:
  num1 = 10                     #attribut de classe
  def __init__(self, num2):
    self.num2 = num2            #attribut d'instance

  def mtd_instance(self, num3):
    print("Une méthode normale.")
    return self.num1 + self.num2 + num3

  @classmethod
  def mtd_class(cls, num3):
    print("Une methode de classe.")
    return cls.num1 + num3

  @staticmethod
  def mtd_statique(num3):
    print("Une methode statique.")
    return num3

Le mot self donne accès aux attributs d’instance dans une méthode d’instance et le mot cls fait référence à la classe pour nous permettre d’accéder aux attributs de la classe dans une méthode de classe.

Nous avons créé une classe Calcul qui possède une variable de classe num1 et une variable d’instance num2. Elle possède également une méthode de chaque type. Comme vous pouvez le constater, la méthode d’instance a accès aux états de la classe et de l’instance et elle prend comme paramètre self ou l’instance.

Cependant la méthode de class a uniquement accès à l’état de la classe et elle prend comme paramètre cls ou la classe elle même.

Quant à la méthode statique n’a accès à aucun des deux états, c’est à dire elle ne prend comme paramètre ni l’instance (self) ni la classe (cls).

obj1 = Calcul(20)
print(obj1.mtd_instance(30))

Une méthode normale
60

Pour appeler une méthode d’instance, nous devons instancier un objet. Si vous l’appelez directement avec la classe, vous aurez une erreur.

En fait, nous pouvons appeler la méthode de classe et la méthode statique à l’aide de l’instance ou de la classe.

obj1 = Calcul(20)

print(obj1.mtd_class(30))
print(Calcul.mtd_class(30))
print(obj1.mtd_statique(30))
print(Calcul.mtd_statique(30))

Une méthode de class
40
Une méthode de class
40
Une méthode statique
30
Une méthode statique
30

Il y a lieu de noter que le fait de pouvoir accéder à un attribut en utilisant le nom de la classe dans une méthode statique ne contredit pas ce qui a été dit. Les méthodes statiques doivent être complètement autonomes et ne fonctionner qu’avec des données transmises en tant qu’arguments.

De plus, une méthode statique peut être appelée sans créer d’objet ou d’instance.

En fait, il est plus judicieux d’appeler la méthode de classe en utilisant le nom de la classe, car elle est complètement liée à la classe.

Donc, ce que vous devez retenir est que les méthodes statiques fonctionnent comme des fonctions normales mais appartiennent à l’espace de noms de la classe. Les méthodes statiques n’ont pas accès à cls ou self, puisqu’elles ne sont pas passées comme paramètres.

Utilisation des méthodes de classe

Les méthodes de classe sont souvent utilisées comme constructeurs alternatifs ou comme méthodes de construction, c’est-à-dire pour créer des instances basées sur différents cas d’utilisation. Disons que nous avons une classe Etudiant ayant des attributs nom, note et date d‘admission.

Le constructeur prend la date d’admission sous la forme d’une année, d’un mois et d’un jour. Certains utilisateurs fournissent les informations dans ce format, mais d’autres donnent la date d’admission sous forme de chaîne de caractère «AAAA-MM-JJ». Pour la forme chaîne, nous utiliserons une méthode de classe comme constructeur alternatif, ce qui permettra à nos utilisateurs d’entrer des informations comme ils le souhaitent.

class Etudiant:
    def __init__(self, nom, note, annee, mois, jour):
        self.nom = nom
        self.note = note
        self.annee = annee
        self.mois = mois
        self.jour = jour

    @classmethod
    def chaîne(cls, nom, note, date_admission):
        annee, mois, jour = date_admission.split("-")
        return cls(nom, note, annee, mois, jour)

    def information(self):
        print(f"Nom: {self.nom}, Note: {self.note}")
        print(f"Date d'admission: Année: {self.annee}, Mois: {self.mois}, Jour: {self.jour}")

La méthode de classe chaîne() est utilisée comme constructeur alternatif pour diviser la chaîne là ou il y a un tiret-. La méthode information() affiche les informations de l’étudiant. Allons maintenant de l’avant et créons des instances de la classe Etudiant en utilisant le constructeur par défaut et alternatif.

etudiant1 = Etudiant("Marie", 10, 2005, 7, 1)
etudiant1.information()

L’exécution du code.

Nom: Marie, Note: 10
Date d‘admission: Année: 2005, Mois: 7, Jour: 1

Et.

etudiant2 = Etudiant.chaîne("Jack", 10, "2008-1-15")
etudiant2.information()

L’exécution du code.

Nom: Jack, Note: 10
Date d‘admission: Année: 2008, Mois: 1, Jour: 15

Les méthodes statiques

Les méthodes statiques sont utilisées pour créer des fonctions utiles. Ces méthodes ont une connexion logique avec la classe, mais n’utilisent pas l’état de la classe ou de l’objet. Ajoutons une méthode statique qui prend la moyenne d’un étudiant et affiche une observation. Cette méthode a une connexion logique avec la classe Etudiant, mais n’utilise pas ses propriétés ou ses méthodes.

class Etudiant:
    def __init__(self, nom, note, annee, mois, jour):
        self.nom = nom
        self.note = note
        self.annee = annee
        self.mois = mois
        self.jour = jour

    @classmethod
    def chaîne(cls, nom, note, date_admission):
        annee, mois, jour = date_admission.split("-")
        return cls(nom, note, annee, mois, jour)

    @staticmethod
    def observation(moyenne):
        if moyenne >= 15 and moyenne <= 20:
            return "Excellent"
        elif moyenne >= 12 and moyenne < 15:
            return "Bon travail"
        elif moyenne >= 10 and moyenne < 12:
            return "Moyen"
        else:
            return "Faible"

    def information(self):
        print(f"Nom: {self.nom}, Note: {self.note}")
        print(f"Date d'admission: Année: {self.annee}, Mois: {self.mois}, Jour: {self.jour}")

Nous allons tester notre méthode statique.

etudiant1 = Etudiant("Marie", 10, 2005, 7, 1)
print(etudiant1.observation(16))

Excellent

Les méthodes statiques ont un cas d’utilisation très clair. Lorsque nous avons besoin de fonctionnalités non pas par rapport à un objet mais par rapport à la classe, nous utiliserons une méthode statique. C’est assez avantageux lorsque nous devons créer des méthodes utiles car elles ne sont généralement pas liées au cycle de vie d’un objet.

À présent vous savez comment les décorateurs @classmethod et @staticmethod fonctionnent en Python.