POO en Python NSI : Comprendre les classes et objets

La programmation orientée objet (POO) est un paradigme fondamental en NSI, surtout en terminale. Elle te permet de structurer ton code en regroupant des données et des fonctions qui agissent sur ces données. En Python, tout est objet : les chaînes, les listes, les dictionnaires... Mais tu peux aussi créer tes propres objets avec des classes. Dans cet article, on va voir ensemble comment définir une classe, créer des objets, et utiliser des concepts comme l'encapsulation et l'héritage. Prêt à devenir un as de la POO ?

Qu'est-ce qu'une classe ? Un objet ?

Imagine une classe comme un moule ou un plan de construction. Par exemple, la classe Voiture définit ce qu'est une voiture : elle a des attributs (couleur, vitesse, marque) et des méthodes (avancer, freiner). Un objet est une instance de cette classe : c'est une voiture concrète, comme une Peugeot 208 rouge.

En Python, on définit une classe avec le mot-clé class :

class Voiture:
    def __init__(self, marque, couleur):
        self.marque = marque
        self.couleur = couleur
        self.vitesse = 0

    def avancer(self, augmentation):
        self.vitesse += augmentation

    def freiner(self, diminution):
        self.vitesse = max(0, self.vitesse - diminution)

Ici, __init__ est le constructeur : il est appelé automatiquement quand on crée un objet. self représente l'objet lui-même. Pour créer une instance :

ma_voiture = Voiture("Peugeot", "rouge")
print(ma_voiture.marque)  # Affiche Peugeot
ma_voiture.avancer(50)
print(ma_voiture.vitesse)  # Affiche 50

Les attributs et méthodes

Les attributs sont les variables liées à un objet. On y accède avec objet.attribut. Les méthodes sont des fonctions définies dans la classe. Elles prennent toujours self en premier paramètre. Tu peux modifier les attributs depuis l'extérieur, mais c'est souvent une mauvaise idée : on préfère utiliser des méthodes pour contrôler les changements.

Exemple avec une classe CompteBancaire :

class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self._solde = solde  # convention : attribut "protégé"

    def deposer(self, montant):
        if montant > 0:
            self._solde += montant

    def retirer(self, montant):
        if 0 < montant <= self._solde:
            self._solde -= montant

    def get_solde(self):
        return self._solde

Ici, _solde est un attribut protégé (convention : un underscore au début). On accède au solde via une méthode get_solde. C'est le principe d'encapsulation : on cache les détails internes et on expose une interface propre.

L'encapsulation en Python

L'encapsulation consiste à protéger les données d'un objet en les rendant privées (ou protégées) et en fournissant des méthodes publiques pour y accéder. En Python, on utilise une convention : _attribut pour protégé, __attribut pour privé (name mangling). Par exemple :

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.__age = age  # attribut privé

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age

p = Personne("Alice", 25)
print(p.get_age())  # 25
# print(p.__age)  # erreur !

L'encapsulation est utile pour éviter les erreurs et pour maintenir un code plus robuste. En NSI, tu n'es pas obligé de tout encapsuler, mais c'est une bonne pratique.

L'héritage : réutiliser du code

L'héritage permet de créer une nouvelle classe à partir d'une classe existante. La nouvelle classe (fille) hérite des attributs et méthodes de la classe mère, et peut les redéfinir ou en ajouter. Exemple avec des véhicules :

class Vehicule:
    def __init__(self, marque):
        self.marque = marque

    def klaxonner(self):
        print("Bip bip !")

class Voiture(Vehicule):
    def __init__(self, marque, couleur):
        super().__init__(marque)  # appel du constructeur parent
        self.couleur = couleur

    def klaxonner(self):  # surcharge
        print("Tut tut !")

v = Voiture("Renault", "bleue")
v.klaxonner()  # Tut tut !
print(v.marque)  # Renault

Le mot-clé super() fait référence à la classe mère. L'héritage est très utilisé en programmation pour éviter de répéter du code.

Méthodes spéciales : __str__, __repr__, __eq__

Python possède des méthodes spéciales (souvent appelées magic methods) entourées de doubles underscores. Les plus courantes :

• __str__ : retourne une chaîne lisible pour l'utilisateur (utilisée par print)
• __repr__ : retourne une représentation officielle de l'objet (utile pour le débogage)
• __eq__ : compare deux objets avec ==

Exemple :

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(3, 4)
p2 = Point(3, 4)
print(p1)  # (3, 4)
print(p1 == p2)  # True

Cas d'usage concret : un jeu de cartes

Prenons un exemple classique : un jeu de cartes. On peut modéliser une carte et un paquet :

class Carte:
    def __init__(self, valeur, couleur):
        self.valeur = valeur
        self.couleur = couleur

    def __str__(self):
        return f"{self.valeur} de {self.couleur}"

class Paquet:
    def __init__(self):
        self.cartes = []
        for couleur in ["Coeur", "Carreau", "Trèfle", "Pique"]:
            for valeur in range(1, 14):
                self.cartes.append(Carte(valeur, couleur))

    def melanger(self):
        import random
        random.shuffle(self.cartes)

    def distribuer(self):
        return self.cartes.pop()

paquet = Paquet()
paquet.melanger()
carte = paquet.distribuer()
print(carte)  # par exemple : 7 de Carreau

Ce code montre comment la POO rend le code modulaire et réutilisable.

Conseils pour le bac NSI et les révisions

Au bac NSI, la POO est un thème important. Tu dois savoir :

• Définir une classe avec des attributs et méthodes
• Utiliser le constructeur __init__
• Comprendre l'encapsulation (attributs privés/protégés)
• Implémenter un héritage simple
• Utiliser super() et les méthodes spéciales

Pour t'entraîner, n'hésite pas à consulter les exercices NSI sur notre site. Tu peux aussi revoir les cours pour consolider tes bases. Si tu bloques sur des erreurs de syntaxe, jette un œil à la page sur les erreurs Python.

Et si tu veux approfondir avec d'autres ressources, tu peux visiter AlloBac ou AlloLycée pour des fiches de révision.

Conclusion

La POO en Python n'est pas si compliquée : une classe est un moule, un objet est une instance. Avec l'encapsulation et l'héritage, tu écris du code plus clair et plus robuste. En t'entraînant régulièrement, tu maîtriseras ces concepts pour le bac et pour la suite. Alors, lance-toi et crée tes propres classes !