T 4.1 Partie 2 : implémenter l'interface

Nous avons abordé le concept de Structure de Données Abstraite, et nous avons vu comment, avec un jeu minimal de primitive, nous pouvons manipuler une LISTE.
Rapellons les primitives utilisées :

  • cree_vide() : création d'une LISTE vide notée []
  • est_vide(liste) : True si la liste est vide et False sinon
  • ajouter(x,liste) ajouter un élément en tête
  • donne_tete(liste) : renvoi la tête
  • donne_queue(liste) : renvoi la queue qui est aussi une LISTE

A vous de créer cette interface

Commençons par cree_vide(). Ce n'est pas très difficile, cette fonction renvoie simplement une liste vide !

Coding Exercise: La primitive cree_vide()

Maintenant la primitive ajouter().

Coding Exercise: La primitive ajouter()
Implémentez ajouter().

La fonction cree_vide() est préprogrammée dans l'exercice. Utilisez la puis utilisez ajouter pour crée et afficher lst = [5, 2, 1]

Maintenant la primitive est_vide().

Là encore c'est très simple...

Coding Exercise: La primitive est_vide()
Implémentez est_vide().

Et pour terminer, donne_tete et donne_queue

Coding Exercise: Les primitives donne_tete et donne_queue()
Implémentez est_vide().

Avec la POO

La POO est un moyen très adapté pour créer des interfaces très faciles à utiliser. Vous allez créer une interface assez similaire aux 2 précédentes, mais utilisant le paradigme de la POO.

création d'une liste vide

On va créer une classe Liste. Les objets Liste auront 1 seul attribut, nommé contenu. Lors de l'instanciation, cet attribut prendra la valeur [].

Coding Exercise: L'objet Liste
Implémentez la classe Liste().

création d'une méthode isempty

Ajoutez dans votre classe (que vous recopierez) une méthode isempty qui renvoie True si la liste est vide et False sinon.

Coding Exercise: L'objet Liste
Implémentez isempty().

création d'une méthode d'ajout

Pour ajouter des éléments nous n'allons pas créer une méthode ajouter.

En fait nous voudrions ajouter des éléments ainsi :

l1 = Liste() -> l1.contenu = []

l2 = Liste(3, l1) # ajoute 3 dans l1 -> l2.contenu = [3]

l3 = Liste(4, l2) # ajoute 3 dans l2 -> l3.contenu = [4, 3]

l4 = Liste(1, l3) # ajoute 3 dans l3-> l4.contenu = [1, 4, 3]

En mode empilé :
l = Liste(5, Liste(3, Liste(4, Liste() ) ) -> l.contenu = [5, 3, 4]
Cela pose un problème : lors de l'instanciation, on écrit l = Liste() sans arguments, tandis que quand on ajoute un élément, on écrit : l = Liste(x, liste), avec 2 arguments. Or, ces 2 instructions appellent la même fonction : le constructeur __init__.

Donc ce constructeur devrait avoir 0 paramètres si on instancie, et 2 paramètres si on ajoute. Cela est possible, en ajoutant des arguments optionnels ayant une valeur par défaut.

Toutefois, le constructeur ainsi modifié est assez complexe, le voici, vous n'avez pas à l'écrire, mais nous allons le commenter pour le comprendre.

Coding Exercise: Modifier le constructeur de L'objet Liste

création des getters get_tete et get_queue

Il s'agit de simples getters, vous pouvez les implémenter.

  • get_tete doit renvoyer contenu[0] si la liste est non vide, et [] sinon
  • get_queue doit renvoyer contenu[1:] si la liste contient au moins 2 éléments (une tête et une queue non vide) et [] sinon
Coding Exercise: get_tete et get_queue
Implémentez les méthodes get_tete et get_queue puis créez une liste dont le contenu sera [4, 5, 6, 1].
Vous afficherez tête et queue de la liste en utilisant les getters.