NSI (Spé) — Langages et programmation
Programmation orientée objet en Python
Classes, attributs, méthodes, encapsulation, héritage, polymorphisme en Python
Résumé synthétiqueFiche en 4 sectionsQuiz de 10 questionsGratuit, sans pub
Résumé
Et si, au lieu d'éparpiller des variables et des fonctions, on rangeait **les données et les actions qui vont ensemble** dans une même boîte ? C'est l'idée de la **programmation orientée objet (POO)**. Une **classe** est un **plan** (le plan d'une voiture) ; un **objet** est un exemplaire concret fabriqué à partir de ce plan (ta voiture). La classe décrit des **attributs** (les données : marque, vitesse) et des **méthodes** (les comportements : accelerer()). Le constructeur **__init__** prépare chaque nouvel objet. L'**encapsulation** range les données sensibles à l'abri ; l'**héritage** permet à une classe fille de **récupérer** tout d'une classe mère puis de l'**enrichir** ; le **polymorphisme** fait répondre chaque objet à sa façon au même appel. Quatre idées qui structurent les gros programmes — et tout le programme de terminale.
Une **classe** est un **modèle** qui décrit ce que tout objet de ce type possède et sait faire. Un **objet** (ou **instance**) est un exemplaire concret créé à partir de ce modèle. On passe de l'un à l'autre par l'**instanciation**.
- **Classe = modèle** décrivant les **attributs** (données) et **méthodes** (comportements) d'un type d'objets.
- **Objet (instance) = exemplaire concret** créé en appelant la classe : p1 = Point(3, 5).
- Le **constructeur __init__(self, ...)** est appelé **automatiquement** à la création : il initialise les attributs.
- **self** est la **référence à l'objet courant** : toujours le **premier paramètre** des méthodes d'instance.
- **Attributs d'instance** (self.x) : propres à chaque objet, définis dans __init__.
- **Attributs de classe** : déclarés dans le corps de la classe, **partagés** par toutes les instances (ex. un compteur).
Exemple
import math
class Point:
def __init__(self, x, y):
self.x = x # attribut d'instance
self.y = y
def distance_origine(self):
return math.hypot(self.x, self.y)
p1 = Point(3, 5) # instanciation : __init__ s'exécute
print(p1.x) # accès à un attribut : affiche 3
Piège à éviter
Oublier **self** comme premier paramètre d'une méthode provoque une **TypeError** (« takes 0 positional arguments but 1 was given »). Python passe **toujours** l'objet en premier argument lors d'un appel objet.methode().
Une **méthode** est une fonction attachée à une classe, appelée par la notation pointée objet.methode(). L'**encapsulation** consiste à regrouper données et traitements, puis à **masquer** les détails internes pour ne montrer qu'une interface simple et sûre.
- **Notation pointée :** objet.methode() exécute la méthode en passant l'objet comme self.
- **Méthodes spéciales :** __str__ (affichage par print), __repr__ (représentation technique), __eq__ (comparaison ==).
- **Encapsulation :** regrouper données + traitements et **cacher** l'implémentation derrière des méthodes publiques.
- **Convention Python :** un attribut préfixé d'un underscore (_solde) est considéré **privé** (à ne pas toucher de l'extérieur).
- **Getter / setter :** méthodes qui contrôlent la lecture et l'écriture d'un attribut (ex. interdire un solde négatif).
- **Intérêt :** l'utilisateur n'a besoin que de l'**interface** (méthodes publiques), jamais des détails internes.
Exemple
class CompteBancaire:
def __init__(self, titulaire, solde=0):
self.titulaire = titulaire
self._solde = solde # privé par convention
def deposer(self, montant):
if montant > 0:
self._solde += montant # contrôle avant écriture
def __str__(self):
return f"Compte de {self.titulaire} : {self._solde} EUR"
Piège à éviter
Modifier directement un attribut « privé » (compte._solde = -1000) **contourne** toutes les vérifications. Le préfixe _ n'interdit rien techniquement : c'est une **convention** de discipline, pas un verrou.
L'**héritage** permet à une **classe fille** de récupérer automatiquement tous les attributs et méthodes d'une **classe mère**, puis d'en **ajouter** ou d'en **redéfinir**. On factorise ainsi le code commun au lieu de le recopier.
- **Syntaxe :** class Fille(Mere): — la fille accède à tout ce qui est défini dans Mere.
- **super().__init__(...)** appelle le constructeur de la mère pour initialiser les attributs hérités.
- **Surcharge (override) :** la fille peut **redéfinir** une méthode héritée (ex. son propre __str__).
- **isinstance(objet, Classe)** vaut True si l'objet est de cette classe **ou d'une sous-classe**.
- **Relation « est-un » :** un Chat **est un** Animal, donc Chat hérite d'Animal (et non l'inverse).
- **Hiérarchie :** on peut enchaîner les héritages, mais une fille n'hérite que vers le **haut** (de ses ancêtres).
Exemple
class Animal:
def __init__(self, nom):
self.nom = nom
def __str__(self):
return f"Animal nommé {self.nom}"
class Chat(Animal):
def __init__(self, nom):
super().__init__(nom) # initialise la partie Animal
def ronronner(self):
return "rrrr"
def __str__(self): # surcharge
return f"Le chat {self.nom}"
Piège à éviter
Oublier d'appeler **super().__init__()** dans le constructeur de la fille laisse les attributs de la mère **non initialisés** : un accès à self.nom lèvera alors une AttributeError.
Le **polymorphisme** (« plusieurs formes ») fait répondre chaque objet **à sa manière** au même appel de méthode. Combiné à des conventions de nommage et au principe de responsabilité unique, il rend le code lisible et extensible.
- **Polymorphisme :** un même appel (print(a)) déclenche le __str__ **propre** à la classe réelle de l'objet.
- On peut parcourir une **liste d'objets hétérogènes** et appeler la même méthode : chacun réagit selon son type.
- **Nommage :** classes en **CamelCase** (CompteBancaire), méthodes et attributs en **snake_case** (solde_courant).
- **Responsabilité unique :** une classe = une responsabilité claire ; sinon, la découper.
- **Docstrings :** documenter classes et méthodes pour expliquer leur rôle (entre triples guillemets).
- **__str__ vs __repr__ :** __str__ pour un affichage lisible à l'humain, __repr__ pour une représentation technique sans ambiguïté.
Exemple
animaux = [Chat("Felix"), Animal("Bête")]
for a in animaux:
print(a) # appelle le __str__ propre à chaque objet
# -> Le chat Felix
# -> Animal nommé Bête (polymorphisme à l'œuvre)
Piège à éviter
Le polymorphisme repose sur la **redéfinition** correcte des méthodes : si Chat oublie de surcharger __str__, c'est celui d'Animal qui s'applique. Vérifie que chaque classe fille redéfinit bien ce qu'elle veut spécialiser.
Quiz - Programmation orientée objet en Python
10 questions
Thème complet
Voir tous les chapitres « Algorithmique et programmation » de la Seconde à la Terminale
Ce thème dans une autre classe
Questions fréquentes
Les points clés à retenir sur Programmation orientée objet en Python, extraits du quiz de révision.
Qu'est-ce qu'une classe en POO ?
Réponse :
Un modèle pour créer des objets
Une classe est un modèle (plan, blueprint) qui définit les attributs et les méthodes communs à un type d'objets. On crée des objets en instanciant la classe.
À quoi sert self en Python ?
Réponse :
À référencer l'objet courant
self est une référence à l'objet courant. Il permet d'accéder aux attributs et méthodes de l'instance à l'intérieur de la classe.
Quelle méthode est appelée automatiquement lors de la création d'un objet ?
Réponse :
__init__
__init__ est le constructeur : il est appelé automatiquement quand on crée un objet avec Classe(). Il initialise les attributs de l'instance.
Comment une classe fille hérite-t-elle en Python ?
Réponse :
class Fille(Mere):
En Python, la syntaxe d'héritage est class Fille(Mere): — le nom de la classe mère est entre parenthèses.