130 lines
4.2 KiB
Markdown
130 lines
4.2 KiB
Markdown
---
|
|
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`.
|