En Python, les méthodes d'une classe peuvent être classées en méthodes d'instance, méthodes de classe et méthodes statiques. Chacun répond à un objectif unique et fournit différents niveaux d'accès à la classe et à ses instances. Dans ce blog, nous explorerons les méthodes de classe et les méthodes statiques, comment les utiliser et les questions d'entretien courantes que vous pourriez rencontrer.

Méthodes d'instance

Avant de plonger dans les méthodes de classe et les méthodes statiques, récapitulons brièvement les méthodes d'instance :

• Méthodes d'instance : ce sont les méthodes les plus courantes dans une classe et sont utilisées pour accéder ou modifier l'état de l'objet. Ils prennent self comme premier paramètre, qui représente l'instance de la classe.

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

    def display_info(self):
        print(f"Car Model: {self.model}, Year: {self.year}")

# Usage
my_car = Car("Toyota", 2020)
my_car.display_info()  # Output: Car Model: Toyota, Year: 2020

Méthodes de classe

Les méthodes de classe sont des méthodes qui ont accès à la classe elle-même, pas seulement aux instances de la classe. Ils prennent cls comme premier paramètre, qui représente la classe. Ils sont définis à l'aide du décorateur @classmethod.

Pourquoi utiliser les méthodes de classe ?

• Pour créer des constructeurs alternatifs.

• Pour accéder ou modifier les attributs au niveau de la classe.

Exemple : constructeur alternatif

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        current_year = 2024
        age = current_year - birth_year
        return cls(name, age)

# Usage
person1 = Person("Alice", 30)  # Using the primary constructor
person2 = Person.from_birth_year("Bob", 1990)  # Using the alternative constructor

print(person1.name, person1.age)  # Output: Alice 30
print(person2.name, person2.age)  # Output: Bob 34

Dans cet exemple, from_birth_year est un constructeur alternatif qui calcule l'âge à partir de l'année de naissance et crée une instance Person.

Exemple : Modification des attributs de classe

class Employee:
    company_name = "TechCorp"

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

    @classmethod
    def change_company(cls, new_name):
        cls.company_name = new_name

# Usage
Employee.change_company("NewTechCorp")
print(Employee.company_name)  # Output: NewTechCorp

Dans cet exemple, change_company est une méthode de classe qui modifie l'attribut de classe company_name.

Méthodes statiques

Les méthodes statiques n'accèdent ni ne modifient les données spécifiques à une classe ou à une instance. Ce sont des méthodes utilitaires qui appartiennent à la classe et sont définies à l'aide du décorateur @staticmethod.

Pourquoi utiliser des méthodes statiques ?

• Pour définir des fonctions utilitaires qui fonctionnent indépendamment des données de classe et d'instance.

• Pour garder le code organisé dans l'espace de noms de la classe.

Exemple : fonction utilitaire

class MathUtils:
    @staticmethod
    def add(a, b):
        return a   b

# Usage
print(MathUtils.add(5, 7))  # Output: 12

Dans cet exemple, add est une méthode statique qui effectue des additions indépendamment de toute donnée de classe ou d'instance.

Comparaison des méthodes

• Méthodes d'instance : opèrent sur une instance de la classe (self).

• Méthodes de classe : opèrent sur la classe elle-même (cls).

• Méthodes statiques : n'opèrez pas sur des données spécifiques à une classe ou à une instance.

Questions d'entretien sur les méthodes de classe et les méthodes statiques

Question 1 : Expliquez la différence entre les méthodes de classe et les méthodes statiques.

• Méthodes de classe : opèrez sur la classe elle-même, en utilisant cls comme premier paramètre. Ils peuvent modifier les données au niveau de la classe.

• Méthodes statiques : sont indépendantes des données spécifiques à la classe et à l'instance. Ils ne prennent pas cls ou self comme premier paramètre.

Question 2 : Implémenter une classe Book avec des méthodes de classe et des méthodes statiques.

class Book:
    def __init__(self, title, author, publication_year):
        self.title = title
        self.author = author
        self.publication_year = publication_year

    @classmethod
    def from_string(cls, book_str):
        title, author, publication_year = book_str.split(', ')
        return cls(title, author, int(publication_year))

    @staticmethod
    def is_valid_year(year):
        return year > 0

# Usage
book1 = Book("Python Basics", "John Doe", 2020)
book2 = Book.from_string("Advanced Python, Jane Smith, 2018")

print(book1.title, book1.author, book1.publication_year)  # Output: Python Basics John Doe 2020
print(book2.title, book2.author, book2.publication_year)  # Output: Advanced Python Jane Smith 2018
print(Book.is_valid_year(2024))  # Output: True

Dans cet exemple, from_string est un constructeur alternatif (méthode de classe) qui crée un objet Book à partir d'une chaîne, et is_valid_year est une méthode statique qui vérifie si une année est valide.

Question 3 : Pourquoi utiliseriez-vous une méthode de classe comme constructeur alternatif ?

Les méthodes de classe en tant que constructeurs alternatifs offrent une flexibilité dans la création d'instances à partir de différents types d'entrées ou de scénarios, rendant le code plus lisible et conservant un emplacement unique pour la logique de création d'objets.

Résumé

• Méthodes d'instance : fonctionnent sur des instances de classe et peuvent modifier les données spécifiques à l'instance.

• Méthodes de classe : opèrent sur la classe elle-même, en utilisant cls comme premier paramètre, et peuvent modifier les données au niveau de la classe.

• Méthodes statiques : n'opèrent pas sur des données spécifiques à une classe ou à une instance et sont utilisées pour des fonctions utilitaires.

En comprenant et en utilisant efficacement ces méthodes, vous pouvez écrire du code orienté objet plus organisé et plus flexible en Python.