Partie 1 : Interface, implémentation et programmation objet¶

Programme officiel (B.O.)¶

B.O. spécial n° 8 du 25 juillet 2019 - NSI Terminale

Contenus	Capacités attendues	Commentaires
Structures de données, interface et implémentation.	Spécifier une structure de données par son interface. Distinguer interface et implémentation. Écrire plusieurs implémentations d'une même structure de données.	L'abstraction des structures de données est un des fondements de l'informatique.
Vocabulaire de la programmation objet : classes, attributs, méthodes, objets.	Écrire la définition d'une classe. Accéder aux attributs et méthodes d'une classe.	On s'appuie sur la programmation objet pour implémenter les structures de données.

1. Interface vs implémentation¶

1.1 Structure de données abstraite¶

Une structure de données est une manière d'organiser des informations pour les manipuler efficacement. On la décrit par son interface : l'ensemble des opérations qu'elle propose, sans préciser comment elles sont réalisées.

L'implémentation est le choix concret de la représentation en mémoire et de l'algorithme de chaque opération.

Analogie

L'interface est comme le mode d'emploi d'un appareil (quels boutons, quelles fonctions), tandis que l'implémentation est le circuit électronique à l'intérieur. L'utilisateur n'a pas besoin de connaître le circuit pour se servir de l'appareil.

1.2 Pourquoi cette distinction ?¶

On peut changer l'implémentation sans modifier le code qui utilise la structure ;
Plusieurs implémentations d'une même interface peuvent avoir des performances différentes ;
Cela favorise la modularité et la réutilisabilité du code.

1.3 Exemple : une structure « Compteur »¶

Interface (ce qu'on peut faire) :

Opération	Description
`creer()`	Créer un compteur initialisé à 0
`incrementer()`	Augmenter le compteur de 1
`valeur()`	Lire la valeur actuelle
`reinitialiser()`	Remettre le compteur à 0

Implémentation A (avec un entier) :

class CompteurEntier:
    def __init__(self):
        self.n = 0

    def incrementer(self):
        self.n += 1

    def valeur(self):
        return self.n

    def reinitialiser(self):
        self.n = 0

Implémentation B (avec une liste) :

class CompteurListe:
    def __init__(self):
        self.elements = []

    def incrementer(self):
        self.elements.append(1)

    def valeur(self):
        return len(self.elements)

    def reinitialiser(self):
        self.elements = []

Les deux implémentations offrent la même interface, mais diffèrent en performance et en mémoire.

2. Programmation orientée objet¶

2.1 Vocabulaire¶

Terme	Définition
Classe	Modèle (plan) qui définit les attributs et méthodes d'un type d'objet
Objet (instance)	Exemplaire concret créé à partir d'une classe
Attribut	Variable attachée à un objet (ses données)
Méthode	Fonction attachée à un objet (ses comportements)
Constructeur	Méthode spéciale `__init__` appelée à la création de l'objet

2.2 Définir une classe¶

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

    def distance_origine(self):    # méthode
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def translater(self, dx, dy):
        self.x += dx
        self.y += dy

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

2.3 Utiliser une classe¶

p = Point(3, 4)              # création d'un objet (instance)
print(p.x)                   # accès à un attribut → 3
print(p.distance_origine())  # appel de méthode → 5.0
p.translater(1, -1)
print(p)                     # → (4, 3)  grâce à __str__

2.4 Méthodes spéciales¶

Python permet de définir des méthodes spéciales (dites dunder methods) pour personnaliser le comportement des objets :

Méthode	Rôle
`__init__(self, ...)`	Constructeur : initialise l'objet
`__str__(self)`	Représentation lisible (`print`, `str()`)
`__repr__(self)`	Représentation technique (console interactive)
`__eq__(self, other)`	Comparaison `==`
`__len__(self)`	Résultat de `len(objet)`

2.5 Encapsulation¶

L'encapsulation consiste à regrouper les données (attributs) et les traitements (méthodes) dans un même objet. L'utilisateur interagit avec l'objet uniquement via ses méthodes, sans connaître la structure interne.

class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self.solde = solde

    def deposer(self, montant):
        assert montant > 0, "Le montant doit être positif"
        self.solde += montant

    def retirer(self, montant):
        assert 0 < montant <= self.solde, "Fonds insuffisants"
        self.solde -= montant

    def __str__(self):
        return f"Compte de {self.titulaire} : {self.solde} €"

À retenir¶

Concept	Description
Interface	Ensemble des opérations offertes par une structure de données
Implémentation	Réalisation concrète (comment les opérations fonctionnent)
Classe	Modèle définissant attributs et méthodes
Objet	Instance concrète d'une classe
Attribut	Donnée attachée à un objet
Méthode	Fonction attachée à un objet
Encapsulation	Regroupement données + traitements dans un objet