---
title: Classes et méthodes magiques
author: Steve Kossouho
---

# Personnalisation des classes

En Python, une classe peut être considérée comme un plan pour créer des objets. Cependant, il est possible de personnaliser le comportement de ces classes de plusieurs manières. Cette personnalisation peut inclure la définition de méthodes spéciales pour gérer le cycle de vie des objets, ainsi que la conversion d'objets en chaînes pour un affichage plus lisible.

----

## Méthodes pour gérer le cycle de vie d'un objet

Dans le cycle de vie d'un objet, il existe plusieurs points clés où nous pouvons intervenir. 
Ce sont la création de l'objet (via un constructeur), son initialisation (via un initialiseur), et sa destruction (via un destructeur).

----

### Écrire un constructeur

En Python, le constructeur est une méthode spéciale qui est utilisée pour créer les objets. 
Il est défini en déclarant dans une classe la méthode spéciale `__new__`.

```python
# Exemple d'une classe avec un constructeur
class Personne:
    def __new__(cls, nom, age):
        instance = super().__new__(cls)
        instance.nom = nom
        instance.age = age
        return instance
```
Dans cet exemple, le constructeur `__new__` prend trois paramètres : `cls` (la classe elle-même), `nom` et `age`. `cls` est l'objet sur lequel la méthode de classe a été appelée, tandis que `nom` et `age` sont des arguments passés lors de la création d'une instance de la classe.

```python
# Création d'une instance de la classe Personne
p = Personne("John", 20)
```

----

### Écrire un initialiseur

En Python, l'initialiseur est une méthode spéciale utilisée pour initialiser les objets. Il est défini en utilisant le mot-clé `__init__`.

```python
# Exemple d'une classe avec un initialiseur
class Voiture:
    def __init__(self, marque, modele):
        self.marque = marque
        self.modele = modele
```
Ici, nous avons une classe `Voiture` avec un initialiseur qui initialise les variables d'instance `marque` et `modele`.

```python
# Création d'une instance de la classe Voiture
v = Voiture("Tesla", "Model 3")
```

----

### Écrire un destructeur

En Python, le destructeur est une méthode spéciale qui est utilisée pour nettoyer les ressources. Il est défini en utilisant le mot-clé `__del__`.

```python
# Exemple d'une classe avec un destructeur
class Fichier:
    def __init__(self, nom):
        self.fichier = open(nom, 'r')

    def __del__(self):
        self.fichier.close()
```
Dans cet exemple, nous avons une classe `Fichier` qui ouvre un fichier lors de sa création et le ferme lors de sa destruction.

```python
# Utilisation de la classe Fichier
f = Fichier("mon_fichier.txt")
del f  # Ceci appelle le destructeur et ferme le fichier
```

----

## Méthodes pratiques de conversion d'un objet

Il peut souvent être utile de convertir nos objets en chaînes, que ce soit pour un affichage plus lisible pour les utilisateurs (méthode `__str__`) ou pour une représentation qui peut être utilisée pour recréer l'objet (méthode `__repr__`).

----

### Méthode `__str__`

La méthode `__str__` en Python représente la classe sous une forme qui peut être lisible par l'utilisateur. Elle est appelée par la fonction `str()` et implicitement utilisée par la fonction `print()`.

```python
# Exemple d'une classe avec la méthode __str__
class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def __str__(self):
        return f"Personne: {self.nom}, Age: {self.age}"

p = Personne("John", 20)
print(p)  # Affiche "Personne: John, Age: 20"
```

----

### Méthode `__repr__`

La méthode `__repr__` en Python représente la classe sous une forme qui peut être utilisée pour recréer l'objet. Elle est appelée par la fonction `repr()`.

```python
# Exemple d'une classe avec la méthode __repr__
class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def __repr__(self):
        return f"Personne('{self.nom}', {self.age})"

p = Personne("John", 20)
print(repr(p))  # Affiche "Personne('John', 20)"
```

Dans cet exemple, `repr(p)` renvoie une chaîne qui montre l'expression à écrire dans du code pour recréer l'objet `p`.
