Programmation orientée objet et mise au point en Terminale
Cours complet, points clés à retenir et exercices d'entraînement de programmation orientée objet et mise au point pour les élèves de Terminale. Conforme au programme officiel.
Réviser notion par notion
Ce que tu vas réviser
- Classes, objets, attributs et méthodes
- Encapsulation et interface publique
- Mise au point : assertions, tests unitaires, débogage
- Modularité et conception logicielle
Classes et objets
Une classe est un modèle (un plan) qui décrit comment créer des objets. Un objet est une instance concrète d'une classe avec ses propres données. C'est comme avoir un plan d'une maison (la classe) et des vraies maisons construites selon ce plan (les objets).
Exemple
La classe Voiture décrit les caractéristiques générales (marque, vitesse). Une Voiture particulière pourrait être une Ferrari rouge : c'est un objet créé à partir de la classe Voiture.
À retenir : Une classe est le modèle, un objet est la réalité créée à partir de ce modèle.
Attributs et méthodes
Les attributs sont les données que possède un objet (ses caractéristiques). Les méthodes sont les actions que l'objet peut faire (les fonctions attachées à l'objet). Ensemble, ils définissent ce qu'un objet est et ce qu'il peut faire.
Exemple
Un joueur de football a des attributs (nom, numéro, position, nombre de buts). Il a des méthodes (tirer, passer, courir). L'attribut « nombre de buts » change quand on appelle la méthode « marquer ».
À retenir : Attributs = données de l'objet ; Méthodes = actions que l'objet peut faire.
Encapsulation et interface publique
L'encapsulation protège les données d'un objet en les cachant. On expose seulement ce qui est nécessaire via une interface publique (les méthodes accessibles). C'est comme un smartphone : tu n'accèdes pas directement aux composants internes, tu passes par l'écran tactile.
Exemple
Un compte bancaire cache le solde réel (attribut privé). On y accède seulement via une méthode publique « consulterSolde() ». On ne peut pas modifier directement le solde en le forçant : on passe par « deposer() » ou « retirer() ».
À retenir : Encapsuler = cacher les données internes et fournir des méthodes contrôlées pour y accéder.
Assertions pour valider le code
Une assertion est une vérification qu'on place dans le code pour s'assurer qu'une condition est vraie. Si elle est fausse, le programme s'arrête et signale une erreur. C'est un outil de développeur pour détecter les bugs.
Exemple
Dans une fonction qui calcule la moyenne : on ajoute l'assertion que la liste n'est pas vide avant de diviser. Si quelqu'un appelle la fonction avec une liste vide, l'assertion échoue et on détecte l'erreur immédiatement.
À retenir : Une assertion vérifie qu'une hypothèse est vraie ; elle capture les erreurs de logique pendant le développement.
Tests unitaires
Un test unitaire est un petit programme qui vérifie qu'une fonction ou une méthode fonctionne correctement sur des cas précis. On teste chaque petit morceau du code indépendamment avant d'assembler le tout.
Exemple
Pour une méthode « calculerRemise() » : on écrit des tests pour vérifier qu'avec 100 € et 10 % de remise, on obtient 90 €. On teste aussi les cas limites (0 €, 100 % de remise, etc.).
À retenir : Les tests unitaires vérifient chaque fonction séparément pour garantir qu'elle fait ce qu'elle doit faire.
Débogage et mise au point
Le débogage est le processus de trouver et corriger les erreurs (bugs) dans le code. On utilise des outils et des stratégies (print, debugger, logs) pour comprendre ce qui va mal et où.
Exemple
Tu as une fonction qui calcule mal les scores. Tu ajoutes des print() avant chaque étape pour voir les valeurs intermédiaires. Tu remarques que la variable « score » est réinitialisée à chaque boucle alors qu'elle ne devrait pas l'être. Tu trouves et corriges le bug.
À retenir : Déboguer = tracer l'exécution du code pour trouver où et pourquoi il se trompe.
Modularité et conception logicielle
La modularité consiste à diviser un grand programme en petites parties indépendantes (modules, classes) qui communiquent entre elles. Chaque partie a une responsabilité claire. C'est plus facile à comprendre, tester et maintenir.
Exemple
Un jeu vidéo : au lieu d'une énorme classe « Jeu », on crée des classes séparées « Joueur », « Ennemi », « Plateau », « Collision », « Graphique ». Chacune gère sa propre logique. Le code est bien organisé et réutilisable.
À retenir : Un bon code est modulaire : divisé en petites pièces bien définies qui travaillent ensemble.
Les points clés
- Une classe se définit avec « class NomClasse: » et utilise « self » pour référencer l'objet courant.
- La méthode « __init__ » (le constructeur) initialise les attributs d'un objet quand il est créé.
- Les attributs privés commencent par « __ » (double underscore) pour signaler qu'on ne doit pas y accéder directement.
- L'encapsulation repose sur le principe : données privées + méthodes publiques de contrôle.
- Une assertion s'écrit « assert condition » et arrête le programme si la condition est fausse.
- Les tests unitaires s'organisent avec une structure : Arrange (préparer), Act (exécuter), Assert (vérifier le résultat).
- Le débogage classique utilise print() pour afficher les valeurs, ou un debugger pour exécuter pas à pas.
- La modularité réduit la complexité et améliore la maintenabilité : un changement localisé n'affecte qu'une partie.
L'essentiel
La POO en Python = créer des classes pour modéliser la réalité (avec attributs et méthodes), les protéger par encapsulation, et les tester rigoureusement pour garantir que le code fonctionne correctement.
Exercices d'entraînement
Entraîne-toi sur ces exercices, puis fais-toi corriger pas à pas par le tuteur.
Exercice 1
Créez une classe « Utilisateur » pour un réseau social avec les attributs privés « nom », « email », « dateInscription ». Implémentez une méthode publique « afficherProfil() » qui retourne les infos. Ajoutez dans le constructeur une assertion qui vérifie que le nom n'est pas vide. Écrivez un test unitaire pour vérifier que le profil s'affiche correctement.
Corrige cet exercice avec le tuteur →Exercice 2
Un jeu de plateforme a besoin d'une classe « Joueur » et d'une classe « Plateforme ». Le Joueur a une position (x, y) et une santé. La Plateforme a une position et une largeur. Écrivez une méthode « deplacer() » dans Joueur avec une assertion qui vérifie que la nouvelle position est valide (pas négative). Concevez les classes de façon modulaire : chacune gère ses responsabilités. Écrivez un test pour vérifier qu'un déplacement invalide déclenche l'assertion.
Corrige cet exercice avec le tuteur →