%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Code et Développement/Programmation/Classes/Classes|Accueil · Classes]]
%% nav-fin %%
# Introduction aux classes en Python
Avant d’écrire une classe, il faut savoir **ce que l’on cherche à modéliser** et **pourquoi une classe est utile**.
### 🔹 Classe et objet : le principe fondamental
En Python, une **classe** est un **modèle** (ou plan) décrivant une entité :
- ce qu’elle **est** → ses **attributs** (données),
- ce qu’elle **fait** → ses **méthodes** (actions).
Un **objet** (ou *instance*) est une **réalisation concrète** de cette classe.
> Une classe définit un type. Un objet est une occurrence de ce type.
### 🔹 Attributs et méthodes
Une classe regroupe deux éléments :
- **Attributs**
Ce sont les variables propres à chaque objet
*(ex. : position, état, valeur, nom…)*
- **Méthodes**
Ce sont des fonctions associées à la classe, qui décrivent les actions possibles de l’objet.
Les méthodes utilisent le mot-clé **`self`** pour accéder aux attributs de l’objet courant.
> `self` désigne l’objet sur lequel la méthode est appelée.
### 🔹 Le constructeur `__init__`
Le constructeur est une méthode spéciale :
- appelée automatiquement lors de la création d’un objet,
- chargée d’initialiser ses attributs.
Il garantit que tout objet est **complet dès sa création**.
### 🔹 Représentation d’un objet : `__str__`
Par défaut, afficher un objet avec `print` donne une information peu lisible.
La méthode spéciale `__str__` permet de définir :
- une représentation textuelle compréhensible,
- utile pour l’affichage, le débogage et la compréhension du programme.
### 🔹 Quand utiliser une classe ?
Une classe est pertinente lorsque :
- plusieurs variables décrivent **une même entité logique**,
- les mêmes fonctions agissent toujours sur les mêmes données,
- le programme commence à devenir difficile à lire ou à faire évoluer.
### 🔹 Pourquoi structurer son code avec des classes ?
L’utilisation des classes permet :
- une **meilleure organisation** du code,
- une **réduction des erreurs** (données et actions regroupées),
- une **meilleure lisibilité**,
- une base pour des notions plus avancées (héritage, composition).
## 📚 Manipuler en Python
### 🔹 Exemple : la classe `Voiture`
La classe `Voiture` décrit une voiture par deux attributs : sa puissance en chevaux fiscaux et sa vitesse en km/h.
Elle définit trois méthodes :
- `__init__`, le constructeur, qui reçoit la puissance et la vitesse de départ ;
- `accelere`, qui augmente la vitesse de `x` km/h ;
- `__str__`, qui renvoie le texte affiché par `print`.
```python
class Voiture:
"""Représente une voiture."""
def __init__(self, puissance, vitesse):
"""Crée une voiture : puissance en chevaux fiscaux, vitesse en km/h."""
self.puissance = puissance
self.vitesse = vitesse
def accelere(self, x):
"""Accélère de x km/h."""
self.vitesse += x
def __str__(self):
"""Texte affiché par print."""
return "Voiture : " + str(self.puissance) + " CV - " + str(self.vitesse) + " km/h"
```
### 🔹 Créer une instance et l'utiliser
L'instruction `Voiture(puissance=6, vitesse=40)` crée un objet. Python appelle alors `__init__`.
```python
v = Voiture(puissance=6, vitesse=40) # appel à __init__
print(v.puissance) # 6
print(v.vitesse) # 40
print(v) # appel à __str__ : Voiture : 6 CV - 40 km/h
v.accelere(2)
print(v) # Voiture : 6 CV - 42 km/h
```
L'appel `v.accelere(2)` exécute la méthode avec `self` égal à `v` et `x` égal à 2. La méthode modifie l'attribut `vitesse` de cet objet. Elle ne renvoie rien.
**À manipuler :** appelez `accelere` avec différentes valeurs, puis affichez l'objet. L'état de `v` se met à jour et la ligne exécutée est surlignée.
```sq-objet
classe: Voiture
instance: v
attributs: puissance=6, vitesse=40
méthode: accelere(x): vitesse += x
affichage: Voiture : {puissance} CV - {vitesse} km/h
---
class Voiture:
"""Représente une voiture."""
def __init__(self, puissance, vitesse):
self.puissance = puissance
self.vitesse = vitesse
def accelere(self, x):
"""Accélère de x km/h."""
self.vitesse += x
def __str__(self):
return "Voiture : " + str(self.puissance) + " CV - " + str(self.vitesse) + " km/h"
```
**À manipuler :** prédisez la sortie de ce programme.
```sq-affiche
v = Voiture(puissance=6, vitesse=40)
v.accelere(2)
print(v.vitesse)
---
réponse: 42
explication: accelere(2) exécute self.vitesse += 2. La vitesse passe de 40 à 42.
```
%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Code et Développement/Programmation/Classes/Classes|Accueil · Classes]]
%% nav-fin %%