Attributs et méthodes

Attributs : les données d'un objet

Les attributs sont les données associées à un objet. Ils représentent l'état de l'objet. On peut les considérer comme des variables qui appartiennent à l'objet.

Les attributs sont généralement définis dans le constructeur (`__init__`) de la classe, mais ils peuvent également être ajoutés ou modifiés dynamiquement après la création de l'objet.

Vous accédez aux attributs d'un objet en utilisant la notation pointée : `objet.attribut`.

Exemple (en reprenant la classe `Cercle`) :

class Cercle:
    def __init__(self, rayon):
        self.rayon = rayon  # rayon est un attribut

c = Cercle(5)
print(c.rayon)  # Accès à l'attribut rayon : affiche 5
c.rayon = 10    # Modification de l'attribut rayon
print(c.rayon)  # Affiche 10

Méthodes : les actions d'un objet

Les méthodes sont les actions que peut effectuer un objet. Ce sont des fonctions définies à l'intérieur de la classe.

Les méthodes peuvent accéder et modifier les attributs de l'objet, et elles peuvent prendre des arguments et retourner des valeurs, comme des fonctions ordinaires.

Comme pour les attributs, on accède aux méthodes avec une notation pointée : `objet.methode(arguments)`

Exemple (toujours avec la classe `Cercle`) :

class Cercle:
    def __init__(self, rayon):
        self.rayon = rayon

    def aire(self):
        return 3.14159 * self.rayon * self.rayon

c = Cercle(5)
aire = c.aire()  # Appel de la méthode aire
print(aire)     # Affiche 78.53975 (environ)

Notez l'utilisation de `self` dans la définition de la méthode `aire`. `self` fait référence à l'objet sur lequel la méthode est appelée (dans ce cas, `c`).

Les méthodes définissent le *comportement* des objets.

Différents types d'attributs

On distingue généralement deux types d'attributs :

• Attributs d'instance : Ce sont les attributs les plus courants. Chaque objet (chaque instance de la classe) a sa propre copie de ces attributs. Ils sont généralement définis dans le constructeur (`__init__`). Dans l'exemple de la classe `Cercle`, `rayon` est un attribut d'instance.
• Attributs de classe : Ces attributs sont partagés par tous les objets de la classe. Ils sont définis directement dans le corps de la classe (en dehors de toute méthode). Ils sont moins courants que les attributs d'instance.

Exemple d'attribut de classe :

class Cercle:
    PI = 3.14159  # Attribut de classe (partagé par tous les cercles)

    def __init__(self, rayon):
        self.rayon = rayon  # Attribut d'instance (propre à chaque cercle)

    def aire(self):
        return Cercle.PI * self.rayon * self.rayon # Utilisation de l'attribut de classe PI

c1 = Cercle(5)
c2 = Cercle(10)

print(c1.PI)      # Affiche 3.14159 (accès via une instance)
print(Cercle.PI)   # Affiche 3.14159 (accès via la classe)
print(c1.aire())   # Affiche 78.53975 (environ)
print(c2.aire()) # Affiche 314.159 (environ)

Dans cet exemple, `PI` est un attribut de classe. Il est partagé par tous les objets `Cercle`. On peut y accéder soit via une instance (`c1.PI`), soit via la classe elle-même (`Cercle.PI`).

Méthodes spéciales (dunder methods)

Python définit de nombreuses méthodes spéciales, reconnaissables à leur nom entouré de doubles tirets de soulignement (double underscore, ou "dunder" en abrégé). Ces méthodes ont une signification particulière et permettent de personnaliser le comportement des objets.

Quelques exemples de méthodes spéciales :

• `__init__(self, ...)` : Le constructeur (déjà vu).
• `__str__(self)` : Retourne une représentation "informelle" de l'objet sous forme de chaîne de caractères (utilisée par `str()` et `print()`).
• `__repr__(self)` : Retourne une représentation "officielle" de l'objet sous forme de chaîne de caractères (utilisée par l'interpréteur interactif et `repr()`).
• `__len__(self)` : Retourne la "longueur" de l'objet (utilisée par `len()`).
• `__add__(self, other)` : Définit le comportement de l'opérateur `+` (addition).
• `__eq__(self, other)` : Définit le comportement de l'opérateur `==` (égalité).
• Et bien d'autres...

Exemple avec `__str__` et `__repr__` :

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

    def __str__(self):
        return f"Point({self.x}, {self.y})"  # Représentation informelle

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"  # Représentation officielle

p = Point(2, 3)
print(p)        # Utilise __str__ : affiche Point(2, 3)
print(str(p))   # Utilise __str__ : affiche Point(2, 3)
print(repr(p))  # Utilise __repr__ : affiche Point(x=2, y=3)

En définissant des méthodes spéciales, vous pouvez faire en sorte que vos objets se comportent comme des types intégrés de Python (par exemple, qu'ils puissent être affichés avec `print()`, comparés avec `==`, etc.).