Une pile lifo est assimilable à un tas:

• quand on ajoute un élément (=empile), c'est sur le dessus de la pile qu'on le met.

• quand on retire un élément (=dépile), c'est l'élément du dessus de la pile qu'on retire (=le dernier arrivé).

Voilà le code proposé:

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# pile lifo (last in first out): on dépile le dernier élément empilé
class Pile(object):
    def __init__(self):
        self._pile=[]
 
    def empile(self,element):
        self._pile.append(element)
 
    def depile(self):
        return self._pile.pop()
 
    def element(self,i=-1):
        return self._pile[i]
 
    def pile(self,imin=0,imax=None):
        if imax=None:
            imax=len(self._pile)
        return list(self._pile[imin:imax])
 
    def estvide(self):
        return len(self._pile)==0
 
    def taille(self):
        return len(self._pile)
 
# exemple d'utilisation:
x=Pile()
print x.pile()  # affiche []
print x.estvide()  # affiche True
x.empile('A')
x.empile(5)
x.empile(['toto','titi','tata'])
print x.pile()  # affiche ['A', 5, ['toto', 'titi', 'tata']]
z=x.depile()
print z  # affiche ['toto', 'titi', 'tata']
print x.pile()  # affiche ['A', 5]
print x.taille()  # affiche 2
print x.element()  # affiche 5

Commentaires sur ce code:

A l'initialisation, par exemple x=Pile() :

• la pile créée appartient à l'instance de classe, c'est à dire que x=Pile() et y=Pile() vont créer 2 piles indépendantes.

x.empile(element):

• on peut empiler n'importe quel objet Python: nombre, chaîne, liste, tuple, dictionnaire, …
• il n'y a pas de limite supérieure à la quantité d'éléments qu'on peut empiler, à part celle de la mémoire de l'ordinateur.

x.depile() ou z=x.depile() :

• on peut dépiler sans récupérer l'élément (x.depile()) ou en le récupérant (z = x.depile())
• une tentative de dépiler une pile vide produit une exception “IndexError” qu'il faudra gérer dans le code utilisateur

x.element() ou x.element(i):

• sans argument, renvoie le dernier élément de la pile sans le dépiler
• avec un argument, renvoie l'élément d'index i. Pour être valide, cet indice doit être: -x.taille() <= i < +x.taille()
• si l'index i n'est pas valide, déclenche une exception “IndexError” qu'il faudra gérer dans le code utilisateur

x.pile() ou x.pile(imin,imax):

• sans argument, renvoie la pile complète sous forme d'une liste. Vous noterez la présente de list() dans le code: sans cela, une modification de la liste renvoyée modifierait la pile.
• avec argument(s), vous pouvez préciser l'index de départ (0 par défaut) et l'index de fin+1 (=x.taille() par défaut):
  • attention: les index d'une liste de longueur lg vont de 0 à lg-1
  • x.pile(2) ou x.pile(imin=2) renvoie comme liste la pile à partir de l'index 2 (=3ème élément) jusqu'à la fin
  • x.pile(2,5) ou x.pile(2,imax=5) ou x.pile(imin=2,imax=5): renvoie comme liste la pile entre les index 2 et 4 compris (5 exclu)
  • x.pile(imax=5): renvoie comme liste la pile entre les index 0 et 4 compris (5 exclu)
  • NB: le syntaxe x.pile(imin=2,5) est interdite (par d'argument simple après un argument nommé)
  • si l'un des index fournis n'est pas valide (hors de -x.taille() <= i < +x.taille()), génère une exception “IndexError” qu'il faudra gérer dans le code utilisateur

x.estvide():

• renvoie True si la pile est vide, et False si elle ne l'est pas.

x.taille():

• renvoie le nombre d'éléments de la pile

Une pile lifo est assimilable à file d'attente:

• quand on ajoute un élément (=empile), c'est sur le dessus de la pile qu'on le met.

• quand on retire un élément (=dépile), c'est l'élément du dessous de la pile qu'on retire (=le plus ancien arrivé).

Voilà le code proposé: