Aller au contenu principal

Les classes en Python (suite)

Attributes de classe et attributs d'instance​

En Python, il existe deux types d'attributs : les attributs de classe et les attributs d'instance. Les attributs de classe sont partagés par toutes les instances de la classe, tandis que les attributs d'instance sont propres à chaque instance.

Les attributs de classe sont définis à l'extérieur des méthodes de la classe. Ils sont accessibles à l'aide de la notation pointée (.) à partir de la classe ou de ses instances. Par exemple, pour définir un attribut de classe compteur qui compte le nombre d'instances de la classe Point, vous pouvez faire :

class Point:
    compteur = 0

    def __init__(self, x, y):
        self.x = x
        self.y = y
        Point.compteur += 1

Dans cet exemple, chaque fois qu'une nouvelle instance de la classe Point est créée, l'attribut de classe compteur est incrémenté de 1. Notez que le mot-clé Point est utilisé pour accéder à l'attribut de classe compteur à l'intérieur de la méthode __init__. Aussi, compteur n'est pas déclaré avec self, ce qui signifie qu'il s'agit d'un attribut de classe.

Les attributs d'instance sont définis à l'intérieur des méthodes de la classe. Ils sont accessibles à l'aide de la notation pointée (.) à partir de l'instance de la classe représentée par self. Par exemple, pour définir un attribut d'instance couleur qui représente la couleur d'un point, vous pouvez faire :

class Point:
    def __init__(self, x, y, couleur):
        self.x = x
        self.y = y
        self.couleur = couleur

Méthodes de classe et méthodes statiques​

Tout comme les attributs, les méthodes peuvent être de classe, statiques ou d'instance. Les méthodes d'instance sont les plus courantes et sont définies à l'intérieur de la classe avec self comme premier argument. Elles agissent sur les données de l'instance de la classe comme dans les exemples précédents.

Méthodes statiques​

Les méthodes statiques sont définies avec le décorateur @staticmethod. Elles n'ont pas accès à l'instance de la classe (self) et ne peuvent pas modifier les attributs de l'instance. Elles sont utilisées pour des fonctions qui n'ont pas besoin d'accéder aux données de l'instance, mais qui sont liées à la classe. Voici un exemple de méthode statique :

class Conversion:
    
    @staticmethod
    def celsius_to_fahrenheit(celsius):
        return (celsius * 9/5) + 32

Souvent, les méthodes statiques auraient pu être des fonctions indépendantes, mais elles sont définies à l'intérieur de la classe pour montrer qu'elles sont liées à la classe ou pour regrouper des fonctions similaires.

info

Dans certains langages de programmation, tout doit être un objet. Les méthodes statiques sont alors les seules façons de définir des fonctions. Java, particulièrement avant Java 8 et les fonctions lambda, est un exemple de langage où les méthodes statiques sont courantes.

Méthodes de classe​

En Python, les classes sont également des objets. Il y a donc l'objet Point qui est une instance de la classe type. Ensuite il y a des objets p1 qui sont des instances de la classe Point. Les méthodes de classe sont définies avec le décorateur @classmethod. Elles prennent l'objet de la classe elle-même comme premier argument, généralement nommé cls. Elles sont utilisées pour des fonctions qui agissent sur la classe plutôt que sur une instance spécifique.

Voici un exemple de méthode de classe qui fournit un constructeur alternatif pour créer une instance de la classe Point à partir d'un dictionnaire :

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    from_dict(cls, data: dict):
        return cls(data['x'], data['y'])

d = {'x': 1, 'y': 2}
p = Point.from_dict(d)

Remarquez que dans cet exemple, lorsque nous appelons la méthode de classe from_dict, il n'y a pas besoin de fournir l'argument cls. Python le passe automatiquement comme pour les méthodes d'instance.

Un autre usage courant des méthodes de classe est la manipulation des attributs de classe. Par exemple, vous pouvez définir une méthode de classe qui incrémente un compteur d'instances de la classe :

class Compteur:
    compte = 0

    @classmethod
    def increment(cls):
        cls.compte += 1

Compteur.increment()
print(Compteur.compte)  # Affiche 1

Méthodes spéciales​

En Python, les méthodes spéciales sont des méthodes qui ont un nom spécial et qui sont appelées automatiquement dans des situations particulières. Par exemple, la méthode __init__ est appelée lors de la création d'une instance de la classe. Voici quelques-unes des méthodes spéciales les plus couramment utilisées :

  • __init__(self, ...): Constructeur de la classe.
  • __str__(self): Méthode appelée par la fonction str pour obtenir une représentation sous forme de chaîne de caractères de l'objet.
  • __repr__(self): Méthode appelée par la fonction repr pour obtenir une représentation sous forme de chaîne de caractères de l'objet. La différence avec __str__ est que __repr__ doit retourner une chaîne de caractères qui peut être évaluée pour recréer l'objet.
  • __eq__(self, other): Méthode appelée lors de l'évaluation de l'égalité entre deux objets à l'aide de l'opérateur ==.
  • __lt__(self, other): Méthode appelée lors de l'évaluation de l'opérateur <.
  • __gt__(self, other): Méthode appelée lors de l'évaluation de l'opérateur >.
  • __le__(self, other): Méthode appelée lors de l'évaluation de l'opérateur <=.
  • __ge__(self, other): Méthode appelée lors de l'évaluation de l'opérateur >=.
  • __add__(self, other): Méthode appelée lors de l'addition de deux objets à l'aide de l'opérateur +.
  • __sub__(self, other): Méthode appelée lors de la soustraction de deux objets à l'aide de l'opérateur -.
  • __mul__(self, other): Méthode appelée lors de la multiplication de deux objets à l'aide
  • __truediv__(self, other): Méthode appelée lors de la division de deux objets à l'aide de l'opérateur /.

Voici un exemple de classe Point qui redéfinit les méthodes __str__ et __eq__ :

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

Dans tous les cas, les méthodes commençant et se terminant par deux traits de soulignement __ sont des méthodes spéciales et ne doivent pas être appelées directement par le programmeur.