La programmation orientée objet

class Point:
    def __init__(self, x, y):
        self.x = x          # attribut d'instance abscisse
        self.y = y          # attribut d'instance ordonnee

    def deplacer(self, dx, dy):
        """Translate le point du vecteur (dx, dy)."""
        self.x += dx
        self.y += dy

    def distance_origine(self):
        """Renvoie la distance du point a l'origine."""
        return (self.x ** 2 + self.y ** 2) ** 0.5

p = Point(3, 4)
print(p.x, p.y)              # 3 4
print(p.distance_origine())  # 5.0
p.deplacer(1, -1)
print(p.x, p.y)              # 4 3

La distance à l'origine d'un point $(x,y)$ vaut $\sqrt{x^2+y^2}$.

Un attribut défini dans __init__ via self est propre à chaque objet : modifier p.x n'affecte pas les autres points. Un attribut défini directement dans le corps de la classe est un attribut de classe, partagé par toutes les instances.

class Compteur:
    nb_instances = 0           # attribut de classe (partage)
    def __init__(self):
        Compteur.nb_instances += 1
        self.id = Compteur.nb_instances  # attribut d'instance

c1 = Compteur(); c2 = Compteur()
print(Compteur.nb_instances)   # 2
print(c1.id, c2.id)            # 1 2

class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self._solde = solde            # attribut "prive"

    def get_solde(self):               # accesseur
        return self._solde

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

    def retirer(self, montant):        # mutateur controle
        if 0 < montant <= self._solde:
            self._solde -= montant
            return True
        return False

c = CompteBancaire("Alice", 100)
c.deposer(50)
print(c.get_solde())   # 150
print(c.retirer(200))  # False : retrait refuse
print(c.get_solde())   # 150

Ici, le solde ne peut jamais devenir négatif, car toute modification passe par les méthodes deposer et retirer qui vérifient la cohérence.

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

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

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

p = Point(3, 4)
print(p)        # (3, 4)        -> __str__
print(str(p))   # (3, 4)        -> __str__
print(repr(p))  # Point(3, 4)   -> __repr__
print([p])      # [Point(3, 4)] -> __repr__ dans un conteneur

De nombreuses méthodes spéciales existent. Les plus utiles en NSI sont :

• __len__(self) : appelée par len(objet) ;
• __eq__(self, autre) : appelée par l'opérateur == ;
• __add__(self, autre) : surcharge de l'opérateur +.

class Vecteur:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, autre):
        return Vecteur(self.x + autre.x, self.y + autre.y)
    def __eq__(self, autre):
        return self.x == autre.x and self.y == autre.y
    def __repr__(self):
        return f"Vecteur({self.x}, {self.y})"

print(Vecteur(1, 2) + Vecteur(3, 4))   # Vecteur(4, 6)
print(Vecteur(1, 2) == Vecteur(1, 2))  # True

class Animal:
    def __init__(self, nom):
        self.nom = nom
    def crier(self):
        return "..."
    def presenter(self):
        return f"{self.nom} fait {self.crier()}"

class Chien(Animal):
    def crier(self):           # redefinition (surcharge)
        return "Wouf"

class Chat(Animal):
    def __init__(self, nom, race):
        super().__init__(nom)  # appel du constructeur parent
        self.race = race
    def crier(self):
        return "Miaou"

print(Chien("Rex").presenter())          # Rex fait Wouf
print(Chat("Felix", "siamois").crier())  # Miaou

La méthode presenter, héritée par Chien, appelle la version redéfinie de crier : c'est le polymorphisme.

class Pile:
    def __init__(self):
        self._elements = []        # representation interne

    def est_vide(self):
        return len(self._elements) == 0

    def empiler(self, valeur):
        self._elements.append(valeur)

    def depiler(self):
        if self.est_vide():
            raise IndexError("depiler sur une pile vide")
        return self._elements.pop()

    def sommet(self):
        if self.est_vide():
            raise IndexError("pile vide")
        return self._elements[-1]

    def __len__(self):
        return len(self._elements)

    def __str__(self):
        return "Pile" + str(self._elements)

p = Pile()
p.empiler(1); p.empiler(2); p.empiler(3)
print(p)              # Pile[1, 2, 3]
print(p.depiler())   # 3
print(len(p))        # 2

from collections import deque

class File:
    def __init__(self):
        self._elements = deque()   # efficace aux deux bouts

    def est_vide(self):
        return len(self._elements) == 0

    def enfiler(self, valeur):
        self._elements.append(valeur)     # ajout en queue

    def defiler(self):
        if self.est_vide():
            raise IndexError("defiler sur une file vide")
        return self._elements.popleft()   # retrait en tete

    def __len__(self):
        return len(self._elements)

f = File()
f.enfiler('a'); f.enfiler('b'); f.enfiler('c')
print(f.defiler())   # a
print(f.defiler())   # b
print(len(f))        # 1

L'emploi de deque rend le défilage en $O(1)$, là où une liste classique imposerait un coût en $O(n)$.

class Noeud:
    def __init__(self, valeur):
        self.valeur = valeur
        self.gauche = None
        self.droit = None

class ABR:
    def __init__(self):
        self.racine = None

    def inserer(self, valeur):
        self.racine = self._inserer(self.racine, valeur)

    def _inserer(self, noeud, valeur):
        if noeud is None:
            return Noeud(valeur)
        if valeur < noeud.valeur:
            noeud.gauche = self._inserer(noeud.gauche, valeur)
        elif valeur > noeud.valeur:
            noeud.droit = self._inserer(noeud.droit, valeur)
        return noeud

    def contient(self, valeur):
        noeud = self.racine
        while noeud is not None:
            if valeur == noeud.valeur:
                return True
            noeud = noeud.gauche if valeur < noeud.valeur else noeud.droit
        return False

    def parcours_infixe(self):
        resultat = []
        self._infixe(self.racine, resultat)
        return resultat

    def _infixe(self, noeud, acc):
        if noeud is not None:
            self._infixe(noeud.gauche, acc)
            acc.append(noeud.valeur)
            self._infixe(noeud.droit, acc)

arbre = ABR()
for v in [5, 3, 8, 1, 4, 7]:
    arbre.inserer(v)
print(arbre.contient(4))        # True
print(arbre.parcours_infixe())  # [1, 3, 4, 5, 7, 8]

Le parcours infixe d'un ABR restitue les valeurs dans l'ordre croissant.