Aller au contenu
Pile et file en programmation objetChapitre 10/12

Ranger la structure dans une classe

AttentionÀ partir d'ici, on fait de la programmation orientée objet (POO) : classes, __init__, self, méthodes. Si ces mots ne te disent rien, fais d'abord le cours POO, puis reviens. Les chapitres 1 à 9 ne demandaient aucune POO.

Au chapitre 4, notre pile était une liste Python accompagnée de fonctions empiler(p, x), depiler(p)... Rien n'empêchait un programme d'écrire p.insert(0, x) ou p[2] et de tricher avec les règles de la pile.

Une classe règle ça : elle regroupe les données (l'attribut contenu) et les opérations autorisées (les méthodes). Celui qui utilise la pile n'appelle que les méthodes : c'est exactement l'interface du chapitre 1.

class Pile:
    def __init__(self):
        self.contenu = []

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

    def empiler(self, x):
        self.contenu.append(x)

    def depiler(self):
        return self.contenu.pop()

    def sommet(self):
        return self.contenu[-1]
p = Pile()
p.empiler("A")
p.empiler("B")
print(p.sommet())    # B
print(p.depiler())   # B
print(p.est_vide())  # False
À retenirLe nom contenu est un détail d'implémentation : celui qui utilise la classe n'a pas à le connaître. Le cours POO montre comment le signaler avec un nom qui commence par _ (encapsulation).
Programme complet du cours structures de données (12 chapitres, gratuit)
  1. 1. Ranger des données dans la mémoire : La RAM est un gros tableau de cases numérotées de 0 à N - 1 : 8 milliards pour 8 Go. Impossible de tout relire pour trouver une donnée, d'où les structures de données : un ordre connu à l'avance et des règles pour y accéder. Interface et implémentation.
  2. 2. Le tableau : des cases côte à côte : Des cases contiguës numérotées : accès direct par l'indice en une seule étape, mais insérer ou supprimer au début oblige à tout décaler.
  3. 3. La liste chaînée : des maillons reliés : Des maillons éparpillés dans la mémoire, chacun connaît l'adresse du suivant : insérer ou supprimer revient à raccrocher une flèche, mais lire le 100e oblige à passer par les 99 premiers.
  4. 4. La pile : dernier arrivé, premier sorti : La pile d'assiettes : on pose en haut, on prend en haut. Empiler, dépiler, sommet, LIFO, et une pile en Python avec append et pop.
  5. 5. La file : premier arrivé, premier servi : La file d'attente : on arrive à la fin, on sort par le début. Enfiler, défiler, FIFO, la différence avec la pile, et une file en Python.
  6. 6. Devine la structure : Le retour d'Insta, Ctrl+Z, la file d'impression, la playlist « à suivre », le distributeur de Pez, la pile d'appels : reconnaître la structure cachée derrière des situations réelles.
  7. 7. Les arbres : ranger en hiérarchie : Arborescence de fichiers, arbre généalogique, tournoi : une racine, des nœuds, des feuilles. Vocabulaire, hauteur, taille et arbre binaire.
  8. 8. Parcourir un arbre : Visiter tous les nœuds d'un arbre, chacun une fois : le parcours en largeur (avec une file), et les parcours en profondeur préfixe, infixe et suffixe.
  9. 9. L'arbre binaire de recherche : Plus petit à gauche, plus grand à droite : chercher une valeur en éliminant la moitié de l'arbre à chaque comparaison, insérer, et pourquoi l'arbre doit rester équilibré.
  10. 10. Pile et file en programmation objet : Écrire les classes Pile et File, puis une file fabriquée avec deux piles : même interface, autre implémentation.
  11. 11. La liste chaînée en programmation objet : Les classes Maillon et ListeChainee : ajouter en tête, parcourir, compter, lire le k-ième, ajouter en queue, supprimer. Puis une pile implémentée par une liste chaînée.
  12. 12. Les arbres en programmation objet : La classe Noeud, la récursivité pour la taille et la hauteur, les parcours préfixe, infixe, suffixe et en largeur, puis l'insertion et la recherche dans un ABR.