Les Méthodes d'Objets en Python

Types de Méthodes

En Python, il existe plusieurs types de méthodes qui peuvent être définies dans une classe :

1. Méthodes d'Instance

Les méthodes d'instance sont les plus courantes. Elles ont accès à l'instance via le paramètre self.


class Car:
    def __init__(self, brand, speed=0):
        self.brand = brand
        self.speed = speed
    
    def accelerate(self, increment):  # Instance method
        self.speed += increment
        return f"{self.brand} is driving at {self.speed} km/h"

# Usage
my_car = Car("Renault")
print(my_car.accelerate(50))  # Renault is driving at 50 km/h

2. Méthodes de Classe

Les méthodes de classe travaillent avec la classe plutôt qu'avec l'instance. Elles sont décorées avec @classmethod.


class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    
    @classmethod
    def from_string(cls, date_str):  # Class method
        year, month, day = map(int, date_str.split('-'))
        return cls(year, month, day)

# Usage
date = Date.from_string('2023-12-25')
print(f"{date.day}/{date.month}/{date.year}")  # 25/12/2023

3. Méthodes Statiques

Les méthodes statiques ne dépendent ni de la classe ni de l'instance. Elles sont décorées avec @staticmethod.


class MathUtils:
    @staticmethod
    def is_even(n):  # Static method
        return n % 2 == 0
    
    @staticmethod
    def is_prime(n):  # Static method
        if n < 2:
            return False
        for i in range(2, int(n ** 0.5) + 1):
            if n % i == 0:
                return False
        return True

# Usage
print(MathUtils.is_even(4))     # True
print(MathUtils.is_prime(7))   # True

4. Méthodes Spéciales

Les méthodes spéciales (ou magic methods) permettent de définir le comportement des objets avec les opérateurs et fonctions built-in.


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):  # Représentation string
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):  # Addition de points
        return Point(self.x + other.x, self.y + other.y)
    
    def __eq__(self, other):  # Égalité de points
        return self.x == other.x and self.y == other.y

# Utilisation
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2

print(p1)          # Point(1, 2)
print(p3)          # Point(4, 6)
print(p1 == p2)    # False

Bonnes Pratiques

Points Clés à Retenir

Prochaines Étapes

That's all folks