Après cette leçon, tu seras capable de :

• Savoir quand une méthode a besoin d'une instance (self), d'une classe (cls) ou d'aucune des deux.
• Définir et appeler une méthode @classmethod pour manipuler des informations au niveau de la classe ou créer des objets.
• Définir et appeler une méthode @staticmethod pour un utilitaire appartenant conceptuellement à une classe.
• Combiner les trois types de méthodes dans une petite classe sans confondre l'état propre à l'objet et l'état partagé.

Une méthode d'instance classique commence par self, l'objet actuel. Tu l'as déjà utilisée pour lire et modifier les attributs créés dans __init__ :

class Job:
    def __init__(self, name):
        self.name = name

    def display_name(self):
        return self.name.upper()

Une méthode de classe commence par cls et est décorée avec @classmethod. Elle reçoit la classe automatiquement, que tu l'appelles via la classe ou via une instance. Les méthodes de classe sont utiles pour lire un paramètre partagé ou construire une instance à partir d'un format d'entrée différent.

Une méthode statique, décorée avec @staticmethod, ne reçoit pas self ou cls automatiquement. Utilise-la pour un calcul ou une validation étroitement lié(e) qui ne nécessite pas l'état d'un objet.

Ces annotations utilisent la syntaxe @..., mais tu n'as pas encore besoin des décorateurs à usage général. @classmethod et @staticmethod sont les formes intégrées dont tu as besoin dans cette leçon.

1. Lire un paramètre partagé avec une méthode de classe

cls fait référence à la classe, de sorte que le résultat utilise son paramètre partagé.

class Mailer:
    default_sender = "robot@example.com"

    @classmethod
    def sender(cls):
        return cls.default_sender

print(Mailer.sender())

Sortie :

robot@example.com

Contrairement à une méthode d'instance, cela peut être appelé sans créer d'objet Mailer.

2. Valider sans état d'objet

Une méthode statique regroupe un utilitaire avec le type auquel il se rapporte. Elle accepte uniquement les paramètres que tu écris.

class PortRules:
    @staticmethod
    def is_allowed(port):
        return 1 <= port <= 65535

print(PortRules.is_allowed(443))

Sortie :

True

Il n'y a pas de self ou cls dans is_allowed car elle n'utilise que port.

3. Créer un objet via une méthode de classe

Une méthode de classe peut offrir un autre moyen de créer une instance valide.

class Badge:
    def __init__(self, title):
        self.title = title

    @classmethod
    def from_text(cls, raw_title):
        return cls(raw_title.strip())

print(Badge.from_text("  Operator  ").title)

Sortie :

Operator

Utiliser cls(...) construit une instance de la classe qui reçoit l'appel.

4. Utiliser une méthode d'instance pour un état individuel

Une méthode utilisant self renvoie des informations sur l'objet spécifique.

class Subscription:
    def __init__(self, plan, active):
        self.plan = plan
        self.active = active

    def status(self):
        if self.active:
            return f"{self.plan}: active"
        return f"{self.plan}: inactive"

print(Subscription("starter", False).status())

Sortie :

starter: inactive

Chaque abonnement peut avoir un état différent, une méthode d'instance est donc appropriée.

• Oublier @classmethod en supposant que cls est transmis automatiquement.
• Déclarer une méthode statique avec self même si l'appelant ne fournit que ses arguments explicites.
• Mettre à jour self.setting lorsque le but est de modifier un paramètre partagé par la classe.
• Utiliser une méthode statique lorsque le comportement doit lire les attributs d'un objet individuel.