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
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"
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.
Une mère Animal factorise nom, âge, manger() ; les filles Chat et Chien en héritent et ajoutent ou redéfinissent des méthodes.
- 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}"
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)
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
S'entraîner
- Quiz : Programmation orientée objet en Python10 questions corrigées sur ce chapitre
- Bac 2026 NSI – MétropoleSujet officiel
- Bac 2025 NSI – MétropoleSujet officiel
- Bac 2024 NSI – MétropoleSujet officiel
- Annales du bac de NSITous les sujets officiels, par année
- Coefficient de NSI au bacPoids de l'épreuve dans la note finale
Thème complet
Voir tous les chapitres « Algorithmique et programmation » de la Seconde à la Terminale
Ce thème dans une autre classe
Articles utiles
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.