Aller au contenu

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 :

  • Méthodes d'instance
  • Méthodes de classe
  • Méthodes statiques
  • Méthodes spéciales

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.

Python
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.

Python
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.

Python
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.

Python
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

  • Utilisez des méthodes d'instance pour les opérations spécifiques à l'objet
  • Préférez les méthodes de classe pour les constructeurs alternatifs
  • Utilisez les méthodes statiques pour les utilitaires indépendants
  • Implémentez les méthodes spéciales pour un comportement naturel

Points Clés à Retenir

  • Les méthodes d'instance manipulent les données de l'objet
  • Les méthodes de classe travaillent avec la classe elle-même
  • Les méthodes statiques sont des utilitaires indépendants
  • Les méthodes spéciales personnalisent le comportement des objets

Prochaines Étapes

  • Héritage et polymorphisme
  • Gestion des exceptions
  • Design patterns en Python